杨其菊/常惠琢《面向对象程序设计（java）》第十一周学习总结

《面向对象程序设计》第十一周学习总结

第一部分：理论知识

JAVA的集合框架
 JAVA的集合框架实现对各种数据结构的封装，以降低对数据管理与处理的难度。
 所谓框架就是一个类库的集合，框架中包含很多超类，编程者创建这些超类的子类可较方便的设计设计程序所需的类。例如：Swing类包
 集合(Collection或称为容器)是一种包含多个元素并提供对所包含元素操作方法的类，其包含的元素可以由同一类型的对象组成，也可以由不同类型的对象组成。
 集合框架：JAVA集合类库的统一架构

集合类的作用
 集合类的作用：
– Java的集合类提供了一些基本数据结构的支持。
– 例如Vector、Hashtable、Stack等。集合类的使用：
– Java的集合类包含在java.util包中。
– import java.util.*;

集合类的特点
 特点一：
– 只容纳对象。
注意：数组可以容纳基本数据类型数据和对象。
– 如果集合类中想使用基本数据类型，又想利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理。

集合类的特点
 特点一：
– 只容纳对象。
注意：数组可以容纳基本数据类型数据和对象。
– 如果集合类中想使用基本数据类型，又想利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理。

特点二：
– 集合类容纳的对象都是Object类的实例，一旦把一个对象置入集合类中，它的类信息将丢失，这样设计的目的是为了集合类的通用性。
– 因为Object类是所有类的祖先，所以可以在这些集合中存放任何类的对象而不受限制，但切记在使用集合成员之前必须对它重新造型。

Vector类
 Vector类类似长度可变的数组。
 Vector中只能存放对象。
 Vector的元素通过下标进行访问。
 Vector类关键属性：
– capacity表示集合最多能容纳的元素个数。
– capacityIncrement表示每次增加多少容量。
– size表示集合当前元素个数。
Vector v = new Vector(100)

 Vector类的关键方法：
– void addElement(Object obj)
– void add(int index, Object element)
– Object elementAt(int index)
– void insertElementAt(Object obj, int index)

Hashtable类
 Hashtable通过键来查找元素。
 Hashtable用散列码（hashcode）来确定键。所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。

集合框架中的基本接口
 Collection：集合层次中的根接口，JDK未提供这个接口的直接实现类。
 Set：不能包含重复的元素。对象可能不是按存放的次序存放，也就是说不能像数组一样按索引的方式进行访问，SortedSet是一个按照升序排列元素的Set。
 List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。
 Map：包含了key-value对。Map不能包含重复的key。
 SortedMap是一个按照升序排列key的Map。

List（教材361页）
 List的明显特征是它的元素都有一个确定的顺序。
 实现它的类有ArrayList和LinkedList。
– ArrayList中的元素在内存中是顺序存储的。
– LinkedList中的元素在内存中是以链表方式存储的。

ArrayList（见教材178页）和linkedList （见教材362页）
 ArrayList：可以将其看作是能够自动增长容量的数组。利用ArrayList的toArray()返回一个数组。
 Arrays.asList()返回一个列表。
 LinkedList是采用双向循环链表实现的。
 利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。
 ArrayList底层采用数组完成，而LinkedList则是以一般的 双向链表(double-linked list)完成，其内每个对象除了数据 本身外，还有两个引用，分别指向前一个元素和后一个元 素。
 如果经常在 List 中进行插入和删除操作，应该使用LinkedList，否则，使用ArrayList将更加快速。

Set
 Set中的元素必须唯一。
 添加到Set中的对象元素必须定义equals方法，以提供算法来判断欲添加进来的对象是否与已经存在的某对象相等，从而建立对象的唯一性。
 实 现 Set 接口的类有HashSet，TreeSet

HashSet（教材365页）
TreeSet（教材369页）
 TreeSet是一个有序集合，TreeSet中元素将按照升序排列，缺省是按照自然顺序进行排列，意味着TreeSet中元素要实现Comparable接口。
 可以在构造 TreeSet 对象时，传递实现了Comparator接口的比较器对象。
 HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。通常使用HashSet，需要排序的功能时，使用TreeSet。

Map定义
 映射（map）是一个存储关键字和值的关联或关键字/值对的对象。给定一个关键字，可以得到它的值。关键字和值都是对象。关键字必须是唯一的。但值是 可以被复制的。
 Map接口映射唯一关键字到值。关键字（key）是以 后用于检索值的对象。给定一个关键字和一个值，可 以存储这个值到一个Map对象中。当这个值被存储以 后，就可以使用它的关键字来检索它
 Map循环使用两个基本操作：get( )和put( )。使用put( )方法可以将一个指定了关键字和值的值加入映 射。为了得到值，可以通过将关键字作为参数来调用get( )方法。调用返回该值。

---

实验十一   集合

实验时间 2018-11-8

1、实验目的与要求

(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API；

(2) 了解java集合框架体系组成；

(3) 掌握ArrayList、LinkList两个类的用途及常用API。

(4) 了解HashSet类、TreeSet类的用途及常用API。

(5)了解HashMap、TreeMap两个类的用途及常用API；

(6) 结对编程（Pair programming）练习，体验程序开发中的两人合作。

2、实验内容和步骤

实验1： 导入第9章示例程序，测试程序并进行代码注释。

测试程序1：

l 使用JDK命令运行编辑、运行以下三个示例程序，结合运行结果理解程序；

l 掌握Vetor、Stack、Hashtable三个类的用途及常用API。

//示例程序1 import java.util.Vector; class Cat { private int catNumber; Cat(int i) { catNumber = i; } void print() { System.out.println("Cat #" + catNumber); } } class Dog { private int dogNumber; Dog(int i) { dogNumber = i; } void print() { System.out.println("Dog #" + dogNumber); } } public class CatsAndDogs { public static void main(String[] args) { Vector cats = new Vector(); for (int i = 0; i < 7; i++) cats.addElement(new Cat(i)); cats.addElement(new Dog(7)); for (int i = 0; i < cats.size(); i++) ((Cat) cats.elementAt(i)).print(); } }

//示例程序2 import java.util.*; public class Stacks { static String[] months = { "1", "2", "3", "4" }; public static void main(String[] args) { Stack stk = new Stack(); for (int i = 0; i < months.length; i++) stk.push(months[i]); System.out.println(stk); System.out.println("element 2=" + stk.elementAt(2)); while (!stk.empty()) System.out.println(stk.pop()); } }

//示例程序3 import java.util.*; class Counter { int i = 1; public String toString() { return Integer.toString(i); } } public class Statistics { public static void main(String[] args) { Hashtable ht = new Hashtable(); for (int i = 0; i < 10000; i++) { Integer r = new Integer((int) (Math.random() * 20)); if (ht.containsKey(r)) ((Counter) ht.get(r)).i++; else ht.put(r, new Counter()); } System.out.println(ht); } }

示例程序1：

 package first;
 //示例程序1
 import java.util.Vector;

 class Cat {
     private int catNumber;

     Cat(int i) {
         catNumber = i;
     }

     void print() {
         System.out.println("Cat #" + catNumber);
     }
 }

 class Dog {
     private int dogNumber;

     Dog(int i) {
         dogNumber = i;
     }

     void print() {
         System.out.println("Dog #" + dogNumber);
     }
 }

 public class CatsAndDogs {
     public static void main(String[] args) {
         Vector cats = new Vector();
         for (int i = ; i < ; i++)
             cats.addElement(new Cat(i));
         cats.addElement(new Dog());
         for (int i = ; i < cats.size(); i++)
             {
             if(cats.elementAt(i) instanceof Cat) {

                   ((Cat) cats.elementAt(i)).print();}

             else
             {
                  ((Dog) cats.elementAt(i)).print();
             }
             }
     }
 }

示例程序2：

示例程序3

测试程序2：

l 使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序，结合程序运行结果理解程序；

import java.util.*; public class ArrayListDemo { public static void main(String[] argv) { ArrayList al = new ArrayList(); // Add lots of elements to the ArrayList... al.add(new Integer(11)); al.add(new Integer(12)); al.add(new Integer(13)); al.add(new String("hello")); // First print them out using a for loop. System.out.println("Retrieving by index:"); for (int i = 0; i < al.size(); i++) { System.out.println("Element " + i + " = " + al.get(i)); } } }

import java.util.*; public class LinkedListDemo { public static void main(String[] argv) { LinkedList l = new LinkedList(); l.add(new Object()); l.add("Hello"); l.add("zhangsan"); ListIterator li = l.listIterator(0); while (li.hasNext()) System.out.println(li.next()); if (l.indexOf("Hello") < 0) System.err.println("Lookup does not work"); else System.err.println("Lookup works"); } }

（1）

（2）

l 在Elipse环境下编辑运行调试教材360页程序9-1，结合程序运行结果理解程序；

l 掌握ArrayList、LinkList两个类的用途及常用API。

 package A;
 import java.util.*;

 /**
  * This program demonstrates operations on linked lists.
  * @version 1.11 2012-01-26
  * @author Cay Horstmann
  */
 public class LinkedListTest
 {
    public static void main(String[] args)
    {
       List<String> a = new LinkedList<>();
       a.add("Amy");
       a.add("Carl");
       a.add("Erica");

       List<String> b = new LinkedList<>();
       b.add("Bob");
       b.add("Doug");
       b.add("Frances");
       b.add("Gloria");

       // merge the words from b into a

       ListIterator<String> aIter = a.listIterator();
       Iterator<String> bIter = b.iterator();

       while (bIter.hasNext())
       {
          if (aIter.hasNext()) aIter.next();
          aIter.add(bIter.next());
       }

       System.out.println(a);

       // remove every second word from b

       bIter = b.iterator();
       while (bIter.hasNext())
       {
          bIter.next(); // skip one element
          if (bIter.hasNext())
          {
             bIter.next(); // skip next element
             bIter.remove(); // remove that element
          }
       }

       System.out.println(b);

       // bulk operation: remove all words in b from a

       a.removeAll(b);

       System.out.println(a);
    }
 }

测试程序3：

l 运行SetDemo程序，结合运行结果理解程序；

import java.util.*; public class SetDemo { public static void main(String[] argv) { HashSet h = new HashSet(); //也可以 Set h=new HashSet() h.add("One"); h.add("Two"); h.add("One"); // DUPLICATE h.add("Three"); Iterator it = h.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

（1）SetDemo：

在Elipse环境下调试教材365页程序9-2，结合运行结果理解程序；了解HashSet类的用途及常用API。

(2)

 package C;

 import java.util.*;

 /**
  * This program uses a set to print all unique words in System.in.
  * @version 1.12 2015-06-21
  * @author Cay Horstmann
  */
 public class SetTest
 {
    public static void main(String[] args)
    {
       Set<String> words = new HashSet<>(); // HashSet implements Set
       long totalTime = 0;

       try (Scanner in = new Scanner(System.in))
       {
          while (in.hasNext())
          {
             String word = in.next();
             long callTime = System.currentTimeMillis();
             words.add(word);
             callTime = System.currentTimeMillis() - callTime;
             totalTime += callTime;
          }
       }

       Iterator<String> iter = words.iterator();
       for (int i = 1; i <= 20 && iter.hasNext(); i++)
          System.out.println(iter.next());
       System.out.println(". . .");
       System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds.");
    }
 }

l 在Elipse环境下调试教材367页-368程序9-3、9-4，结合程序运行结果理解程序；了解TreeSet类的用途及常用API。

(3)TreeSet

 package B;

 import java.util.*;

 /**
  * This program sorts a set of item by comparing their descriptions.
  * @version 1.12 2015-06-21
  * @author Cay Horstmann
  */
 public class TreeSetTest
 {
    public static void main(String[] args)
    {
       SortedSet<Item> parts = new TreeSet<>();
       parts.add(new Item("Toaster", 1234));
       parts.add(new Item("Widget", 4562));
       parts.add(new Item("Modem", 9912));
       System.out.println(parts);

       NavigableSet<Item> sortByDescription = new TreeSet<>(
             Comparator.comparing(Item::getDescription));

       sortByDescription.addAll(parts);
       System.out.println(sortByDescription);
    }
 }

 package B;

 import java.util.*;

 /**
  * An item with a description and a part number.
  */
 public class Item implements Comparable<Item>
 {
    private String description;
    private int partNumber;

    /**
     * Constructs an item.
     *
     * @param aDescription
     *           the item's description
     * @param aPartNumber
     *           the item's part number
     */
    public Item(String aDescription, int aPartNumber)
    {
       description = aDescription;
       partNumber = aPartNumber;
    }

    /**
     * Gets the description of this item.
     *
     * @return the description
     */
    public String getDescription()
    {
       return description;
    }

    public String toString()
    {
       return "[description=" + description + ", partNumber=" + partNumber + "]";
    }

    public boolean equals(Object otherObject)
    {
       if (this == otherObject) return true;
       if (otherObject == null) return false;
       if (getClass() != otherObject.getClass()) return false;
       Item other = (Item) otherObject;
       return Objects.equals(description, other.description) && partNumber == other.partNumber;
    }

    public int hashCode()
    {
       return Objects.hash(description, partNumber);
    }

    public int compareTo(Item other)
    {
       int diff = Integer.compare(partNumber, other.partNumber);
       return diff != 0 ? diff : description.compareTo(other.description);
    }
 }

测试程序4：

l 使用JDK命令运行HashMapDemo程序，结合程序运行结果理解程序；

import java.util.*; public class HashMapDemo { public static void main(String[] argv) { HashMap h = new HashMap(); // The hash maps from company name to address. h.put("Adobe", "Mountain View, CA"); h.put("IBM", "White Plains, NY"); h.put("Sun", "Mountain View, CA"); String queryString = "Adobe"; String resultString = (String)h.get(queryString); System.out.println("They are located in: " +  resultString); } }

l 在Elipse环境下调试教材373页程序9-6，结合程序运行结果理解程序；

l 了解HashMap、TreeMap两个类的用途及常用API。

 package second;

 import java.util.*;

 /**
  * This program demonstrates the use of a map with key type String and value type Employee.
  * @version 1.12 2015-06-21
  * @author Cay Horstmann
  */
 public class MapTest
 {
    public static void main(String[] args)
    {
       Map<String, Employee> staff = new HashMap<>();
       staff.put("144-25-5464", new Employee("Amy Lee"));
       staff.put("567-24-2546", new Employee("Harry Hacker"));
       staff.put("157-62-7935", new Employee("Gary Cooper"));
       staff.put("456-62-5527", new Employee("Francesca Cruz"));

       // print all entries

       System.out.println(staff);

       // remove an entry

       staff.remove("567-24-2546");

       // replace an entry

       staff.put("456-62-5527", new Employee("Francesca Miller"));

       // look up a value

       System.out.println(staff.get("157-62-7935"));

       // iterate through all entries

       staff.forEach((k, v) ->
          System.out.println("key=" + k + ", value=" + v));
    }
 }

 package second;

 /**
  * A minimalist employee class for testing purposes.
  */
 public class Employee
 {
    private String name;
    private double salary;

    /**
     * Constructs an employee with $0 salary.
     * @param n the employee name
     */
    public Employee(String name)
    {
       this.name = name;
       salary = 0;
    }

    public String toString()
    {
       return "[name=" + name + ", salary=" + salary + "]";
    }
 }

实验2：结对编程练习：

l 关于结对编程：以下图片是一个结对编程场景：两位学习伙伴坐在一起，面对着同一台显示器，使用着同一键盘，同一个鼠标，他们一起思考问题，一起分析问题，一起编写程序。

l 关于结对编程的阐述可参见以下链接：

http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

http://en.wikipedia.org/wiki/Pair_programming

l 对于结对编程中代码设计规范的要求参考：

http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

以下实验，就让我们来体验一下结对编程的魅力。

l 确定本次实验结对编程合作伙伴；

l 各自运行合作伙伴实验九编程练习1，结合使用体验对所运行程序提出完善建议；

l 各自运行合作伙伴实验十编程练习2，结合使用体验对所运行程序提出完善建议；

l 采用结对编程方式，与学习伙伴合作完成实验九编程练习1；

l 采用结对编程方式，与学习伙伴合作完成实验十编程练习2。

(1)实验九编程练习1

我的（杨其菊）

 import java.io.BufferedReader;
         import java.io.File;
         import java.io.FileInputStream;
         import java.io.FileNotFoundException;
         import java.io.IOException;
         import java.io.InputStreamReader;
         import java.util.ArrayList;
         import java.util.Arrays;
         import java.util.Collections;
         import java.util.Scanner;

 public class Search{

       private static ArrayList<Person> Personlist1;
        public static void main(String[] args) {

           Personlist1 = new ArrayList<>();

           Scanner scanner = new Scanner(System.in);
           File file = new File("E:\\面向对象程序设计Java\\实验\\实验六\\身份证号.txt");

                 try {
                      FileInputStream F = new FileInputStream(file);
                      BufferedReader in = new BufferedReader(new InputStreamReader(F));
                      String temp = null;
                      while ((temp = in.readLine()) != null) {

                         Scanner linescanner = new Scanner(temp);

                         linescanner.useDelimiter(" ");
                         String name = linescanner.next();
                         String id = linescanner.next();
                         String sex = linescanner.next();
                         String age = linescanner.next();
                         String place =linescanner.nextLine();
                         Person Person = new Person();
                         Person.setname(name);
                         Person.setid(id);
                         Person.setsex(sex);
                         int a = Integer.parseInt(age);
                         Person.setage(a);
                         Person.setbirthplace(place);
                         Personlist1.add(Person);

                     }
                 } catch (FileNotFoundException e) {
                     System.out.println("查找不到信息");
                     e.printStackTrace();
                 } catch (IOException e) {
                     System.out.println("信息读取有误");
                     e.printStackTrace();
                 }
                 boolean isTrue = true;
                 while (isTrue) {
                     System.out.println("******************************************");
                     System.out.println("1:按姓名字典顺序输出信息；");
                     System.out.println("2:查询最大年龄与最小年龄人员信息；");
                     System.out.println("3：按省份找你的同乡；");
                     System.out.println("4:输入你的年龄,查询年龄与你最近人的信息；");
                     System.out.println("5：退出");
                     System.out.println("******************************************");
                     int type = scanner.nextInt();
                     switch (type) {
                     case 1:
                         Collections.sort(Personlist1);
                         System.out.println(Personlist1.toString());
                         break;
                     case 2:

                         int max=0,min=100;int j,k1 = 0,k2=0;
                         for(int i=1;i<Personlist1.size();i++)
                         {
                             j=Personlist1.get(i).getage();
                            if(j>max)
                            {
                                max=j;
                                k1=i;
                            }
                            if(j<min)
                            {
                                min=j;
                                k2=i;
                            }

                         }
                         System.out.println("年龄最大："+Personlist1.get(k1));
                         System.out.println("年龄最小："+Personlist1.get(k2));
                         break;
                     case 3:
                         System.out.println("place?");
                         String find = scanner.next();
                         String place=find.substring(0,3);
                         String place2=find.substring(0,3);
                         for (int i = 0; i <Personlist1.size(); i++)
                         {
                             if(Personlist1.get(i).getbirthplace().substring(1,4).equals(place))
                             {
                                 System.out.println("你的同乡："+Personlist1.get(i));
                             }
                         } 

                         break;
                     case 4:
                         System.out.println("年龄：");
                         int yourage = scanner.nextInt();
                         int close=ageclose(yourage);
                         int d_value=yourage-Personlist1.get(close).getage();
                         System.out.println(""+Personlist1.get(close));

                         break;
                     case 5:
                    isTrue = false;
                    System.out.println("再见!");
                         break;
                     default:
                         System.out.println("输入有误");
                     }
                 }
             }
             public static int ageclose(int age) {
                    int m=0;
                 int    max=53;
                 int d_value=0;
                 int k=0;
                 for (int i = 0; i < Personlist1.size(); i++)
                 {
                     d_value=Personlist1.get(i).getage()-age;
                     if(d_value<0) d_value=-d_value;
                     if (d_value<max)
                     {
                        max=d_value;
                        k=i;
                     }

                  }    return k;

              }

  }

 //jiekouwenjiaan

 public class Person implements Comparable<Person> {
             private String name;
             private String id;
             private int age;
             private String sex;
             private String birthplace;

     public String getname() {
         return name;
         }
     public void setname(String name) {
         this.name = name;
     }
     public String getid() {
         return id;
     }
     public void setid(String id) {
         this.id= id;
     }
     public int getage() {

         return age;
     }
     public void setage(int age) {
         // int a = Integer.parseInt(age);
         this.age= age;
     }
     public String getsex() {
         return sex;
     }
     public void setsex(String sex) {
         this.sex= sex;
     }
     public String getbirthplace() {
         return birthplace;
     }
     public void setbirthplace(String birthplace) {
         this.birthplace= birthplace;
 }

     public int compareTo(Person o) {
         return this.name.compareTo(o.getname());

 }

     public String toString() {
         return  name+"\t"+sex+"\t"+age+"\t"+id+"\t";

 }

 }

Search

伙伴（常惠琢）：

  import java.io.BufferedReader;
         import java.io.File;
         import java.io.FileInputStream;
         import java.io.FileNotFoundException;
         import java.io.IOException;
         import java.io.InputStreamReader;
         import java.util.ArrayList;
         import java.util.Arrays;
         import java.util.Collections;
         import java.util.Scanner;

 public class Test {
     private static ArrayList<Student> studentlist;
     public static void main(String[] args) {

                 studentlist = new ArrayList<>();
                 Scanner scanner = new Scanner(System.in);
                 File file = new File("F:\\java\\身份证号.txt");
                 try {
                     FileInputStream fis = new FileInputStream(file);
                     BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                     String temp = null;
                     while ((temp = in.readLine()) != null) {

                         Scanner linescanner = new Scanner(temp);

                         linescanner.useDelimiter(" ");
                         String name = linescanner.next();
                         String number = linescanner.next();
                         String sex = linescanner.next();
                         String age = linescanner.next();
                         String province =linescanner.nextLine();
                         Student student = new Student();
                         student.setName(name);
                         student.setnumber(number);
                         student.setsex(sex);
                         int a = Integer.parseInt(age);
                         student.setage(a);
                         student.setprovince(province);
                         studentlist.add(student);

                     }
                 } catch (FileNotFoundException e) {
                     System.out.println("找不到学生的信息文件");
                     e.printStackTrace();
                 } catch (IOException e) {
                     System.out.println("学生信息文件读取错误");
                     e.printStackTrace();
                 }
                 boolean isTrue = true;
                 while (isTrue) {
                     System.out.println("选择你的操作， ");
                     System.out.println("1.字典排序  ");
                     System.out.println("2.输出年龄最大和年龄最小的人  ");
                     System.out.println("3.寻找同乡  ");
                     System.out.println("4.寻找年龄相近的人  ");
                     System.out.println("5.退出 ");
                     String m = scanner.next();
                     switch (m) {
                     case "1":
                         Collections.sort(studentlist);
                         System.out.println(studentlist.toString());
                         break;
                     case "2":
                          int max=0,min=100;
                          int j,k1 = 0,k2=0;
                          for(int i=1;i<studentlist.size();i++)
                          {
                              j=studentlist.get(i).getage();
                          if(j>max)
                          {
                              max=j;
                              k1=i;
                          }
                          if(j<min)
                          {
                            min=j;
                            k2=i;
                          }

                          }
                          System.out.println("年龄最大："+studentlist.get(k1));
                          System.out.println("年龄最小："+studentlist.get(k2));
                         break;
                     case "3":
                          System.out.println("地址?");
                          String find = scanner.next();
                          String place=find.substring(0,3);
                          for (int i = 0; i <studentlist.size(); i++)
                          {
                              if(studentlist.get(i).getprovince().substring(1,4).equals(place))
                                  System.out.println("同乡"+studentlist.get(i));
                          }
                          break;

                     case "4":
                         System.out.println("年龄：");
                         int yourage = scanner.nextInt();
                         int near=agenear(yourage);
                         int value=yourage-studentlist.get(near).getage();
                         System.out.println(""+studentlist.get(near));
                         break;
                     case "5 ":
                         isTrue = false;
                         System.out.println("退出程序!");
                         break;
                         default:
                         System.out.println("输入有误");

                     }
                 }
             }
                 public static int agenear(int age) {
                 int j=0,min=53,value=0,ok=0;
                  for (int i = 0; i < studentlist.size(); i++)
                  {
                      value=studentlist.get(i).getage()-age;
                      if(value<0) value=-value;
                      if (value<min)
                      {
                         min=value;
                          ok=i;
                      }
                   }
                  return ok;
               }
         }

Main

  import java.io.BufferedReader;
         import java.io.File;
         import java.io.FileInputStream;
         import java.io.FileNotFoundException;
         import java.io.IOException;
         import java.io.InputStreamReader;
         import java.util.ArrayList;
         import java.util.Arrays;
         import java.util.Collections;
         import java.util.Scanner;

 public class Test {
     private static ArrayList<Student> studentlist;
     public static void main(String[] args) {

                 studentlist = new ArrayList<>();
                 Scanner scanner = new Scanner(System.in);
                 File file = new File("F:\\java\\身份证号.txt");
                 try {
                     FileInputStream fis = new FileInputStream(file);
                     BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                     String temp = null;
                     while ((temp = in.readLine()) != null) {

                         Scanner linescanner = new Scanner(temp);

                         linescanner.useDelimiter(" ");
                         String name = linescanner.next();
                         String number = linescanner.next();
                         String sex = linescanner.next();
                         String age = linescanner.next();
                         String province =linescanner.nextLine();
                         Student student = new Student();
                         student.setName(name);
                         student.setnumber(number);
                         student.setsex(sex);
                         int a = Integer.parseInt(age);
                         student.setage(a);
                         student.setprovince(province);
                         studentlist.add(student);

                     }
                 } catch (FileNotFoundException e) {
                     System.out.println("找不到学生的信息文件");
                     e.printStackTrace();
                 } catch (IOException e) {
                     System.out.println("学生信息文件读取错误");
                     e.printStackTrace();
                 }
                 boolean isTrue = true;
                 while (isTrue) {
                     System.out.println("选择你的操作， ");
                     System.out.println("1.字典排序  ");
                     System.out.println("2.输出年龄最大和年龄最小的人  ");
                     System.out.println("3.寻找同乡  ");
                     System.out.println("4.寻找年龄相近的人  ");
                     System.out.println("5.退出 ");
                     String m = scanner.next();
                     switch (m) {
                     case "1":
                         Collections.sort(studentlist);
                         System.out.println(studentlist.toString());
                         break;
                     case "2":
                          int max=0,min=100;
                          int j,k1 = 0,k2=0;
                          for(int i=1;i<studentlist.size();i++)
                          {
                              j=studentlist.get(i).getage();
                          if(j>max)
                          {
                              max=j;
                              k1=i;
                          }
                          if(j<min)
                          {
                            min=j;
                            k2=i;
                          }

                          }
                          System.out.println("年龄最大："+studentlist.get(k1));
                          System.out.println("年龄最小："+studentlist.get(k2));
                         break;
                     case "3":
                          System.out.println("地址?");
                          String find = scanner.next();
                          String place=find.substring(0,3);
                          for (int i = 0; i <studentlist.size(); i++)
                          {
                              if(studentlist.get(i).getprovince().substring(1,4).equals(place))
                                  System.out.println("同乡"+studentlist.get(i));
                          }
                          break;

                     case "4":
                         System.out.println("年龄：");
                         int yourage = scanner.nextInt();
                         int near=agenear(yourage);
                         int value=yourage-studentlist.get(near).getage();
                         System.out.println(""+studentlist.get(near));
                         break;
                     case "5 ":
                         isTrue = false;
                         System.out.println("退出程序!");
                         break;
                         default:
                         System.out.println("输入有误");

                     }
                 }
             }
                 public static int agenear(int age) {
                 int j=0,min=53,value=0,ok=0;
                  for (int i = 0; i < studentlist.size(); i++)
                  {
                      value=studentlist.get(i).getage()-age;
                      if(value<0) value=-value;
                      if (value<min)
                      {
                         min=value;
                          ok=i;
                      }
                   }
                  return ok;
               }
         }

Test

完善：

1.文件输出字体格式不一致，在整体美观上尚可修改。

2.编程过程存在变量使用混乱不清的问题。

(2)实验十编程练习2

我的：

 package a;

 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 import java.util.Scanner;

 import org.w3c.dom.css.Counter;

 public class Main{
     public static void main(String[] args) {

         Scanner in = new Scanner(System.in);
         counter counter=new  counter();
         PrintWriter output = null;
         try {
             output = new PrintWriter("result.txt");
         } catch (Exception e) {
             //e.printStackTrace();
         }
         int sum = 0;

         for (int i = 1; i < 11; i++) {
             int a = (int) Math.round(Math.random() * 100);
             int b = (int) Math.round(Math.random() * 100);
             int type = (int) Math.round(Math.random() * 4);

            switch(type)
            {
            case 1:
                System.out.println(i+": "+a+"/"+b+"=");
                while(b==0){
                    b = (int) Math.round(Math.random() * 100);
                    }
                double c = in.nextDouble();
                output.println(a+"/"+b+"="+c);
                if (c == counter.Chu(a, b))
                {
                    sum += 10;
                    System.out.println("恭喜答案正确!");
                }
                else {
                    System.out.println("答案错误!");
                } break;

            case 2:
                System.out.println(i+": "+a+"*"+b+"=");
                int c1 = in.nextInt();
                output.println(a+"*"+b+"="+c1);
                if (c1 == counter.Cheng(a, b)) {
                    sum += 10;
                    System.out.println("恭喜答案正确!");
                }
                else {
                    System.out.println("答案错误!");
                }break;
            case 3:
                System.out.println(i+": "+a+"+"+b+"=");
                int c2 = in.nextInt();
                output.println(a+"+"+b+"="+c2);
                if (c2 ==  counter.Jia(a, b)) {
                    sum += 10;
                    System.out.println("恭喜答案正确!");
                }
                else {
                    System.out.println("答案错误!");
                }break ;
            case 4:
                System.out.println(i+": "+a+"-"+b+"=");
                int c3 = in.nextInt();
                output.println(a+"-"+b+"="+c3);
                if (c3 ==  counter.Jian(a, b)) {
                    sum += 10;
                    System.out.println("恭喜答案正确!");
                }
                else {
                    System.out.println("答案错误!");
                }break ;

              } 

           }
         System.out.println("成绩"+sum);
         output.println("成绩:"+sum);
         output.close();

     }
 }    

 Main

Main

package a;

public class counter {
       private int a;
       private int b;

               public int  Jia(int a,int b)
               {
                   return a+b;
               }
               public int   Jian(int a,int b)
               {
                   if((a-b)<0)
                       return 0;
                   else
                   return a-b;
               }
               public int   Cheng(int a,int b)
               {
                   return a*b;
               }
               public int   Chu(int a,int b)
               {
                   if(b!=0)
                   return a/b;
                   else
               return 0;
               }

       }

counter

counter

伙伴：

 java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.Scanner;
 public class Fine {

     public static void main(String[] args) {
                 Scanner in = new Scanner(System.in);
                 Min min=new Min();
                 PrintWriter out = null;
                 try {
                     out = new PrintWriter("test.txt");
                     int sum = 0;
                     for (int i = 1; i <=10; i++) {
                         int a = (int) Math.round(Math.random() * 100);
                         int b = (int) Math.round(Math.random() * 100);
                         int menu = (int) Math.round(Math.random() * 3);
                         switch (menu) {
                         case 0:
                             System.out.println(i+":"+a + "+" + b + "=");
                             int c1 = in.nextInt();
                             out.println(a + "+" + b + "=" + c1);
                             if (c1 == (a + b)) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }
                             break;
                         case 1:
                             while (a < b) {
                                 b = (int) Math.round(Math.random() * 100);
                             }
                             System.out.println(i+":"+a + "-" + b + "=");
                             int c2 = in.nextInt();
                             out.println(a + "-" + b + "=" + c2);
                             if (c2 == (a - b)) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         case 2:
                             System.out.println(i+":"+a + "*" + b + "=");
                             int c3 = in.nextInt();
                             out.println(a + "*" + b + "=" + c3);
                             if (c3 == a * b) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         case 3:
                              while(b == 0){
                                     b = (int) Math.round(Math.random() * 100);
                                 }
                                 while(a % b != 0){
                                     a = (int) Math.round(Math.random() * 100);

                                 }
                             System.out.println(i+":"+a + "/" + b + "=");
                             int c4 = in.nextInt();
                             if (c4 == a / b) {
                                 sum += 10;
                                 System.out.println("恭喜，答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         }
                     }
                     System.out.println("你的得分为" + sum);
                     out.println("你的得分为" + sum);
                     out.close();
                 } catch (FileNotFoundException e) {
                     e.printStackTrace();
                 }
             }
         }

Main

  public class Min<T> {
     private T a;
     private T b;
     public Min() {
         a=null;
         b=null;
     }
     public Min(T a,T b) {
         this.a=a;
         this.b=b;
     }
     public int count1(int a,int b) {
         return a+b;
     }
     public int count2(int a,int b) {
         return a-b;
     }
     public int count3(int a,int b) {
         return a*b;
     }
     public int count4(int a,int b) {
         return a/b;
     }
 }

完善：

      1.没有全面考虑小学生的实际状况：减法算法结果可能出现负数的情况，以及除法的运算结果直接取整输出，都不符合小学生的学习范围；                

     2.编程过程中，关于变量的使用混乱问题；                      

      3.结果没有输出到文件中；

（3）合作实验九编程练习1；

 package Second;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Scanner;

 public class Search{

 private static ArrayList<Person> Personlist1;
 public static void main(String[] args) {

   Personlist1 = new ArrayList<>();

   Scanner scanner = new Scanner(System.in);
   File file = new File("E:\\面向对象程序设计Java\\实验\\实验六\\身份证号.txt");

         try {
              FileInputStream F = new FileInputStream(file);
              BufferedReader in = new BufferedReader(new InputStreamReader(F));
              String temp = null;
              while ((temp = in.readLine()) != null) {

                 Scanner linescanner = new Scanner(temp);

                 linescanner.useDelimiter(" ");
                 String name = linescanner.next();
                 String id = linescanner.next();
                 String sex = linescanner.next();
                 String age = linescanner.next();
                 String place =linescanner.nextLine();
                 Person Person = new Person();
                 Person.setname(name);
                 Person.setid(id);
                 Person.setsex(sex);
                 int a = Integer.parseInt(age);
                 Person.setage(a);
                 Person.setbirthplace(place);
                 Personlist1.add(Person);

             }
         } catch (FileNotFoundException e) {
             System.out.println("查找不到信息");
             e.printStackTrace();
         } catch (IOException e) {
             System.out.println("信息读取有误");
             e.printStackTrace();
         }
         boolean isTrue = true;
         while (isTrue) {
             System.out.println("******************************************");
             System.out.println("1:按姓名字典顺序输出信息；");
             System.out.println("2:查询最大年龄与最小年龄人员信息；");
             System.out.println("3：按省份找你的同乡；");
             System.out.println("4:输入你的年龄,查询年龄与你最近人的信息；");
             System.out.println("5：退出");
             System.out.println("******************************************");
             int type = scanner.nextInt();
             switch (type) {
             case 1:
                 Collections.sort(Personlist1);
                 System.out.println(Personlist1.toString());
                 break;
             case 2:

                 int max=0,min=100;int j,k1 = 0,k2=0;
                 for(int i=1;i<Personlist1.size();i++)
                 {
                     j=Personlist1.get(i).getage();
                    if(j>max)
                    {
                        max=j;
                        k1=i;
                    }
                    if(j<min)
                    {
                        min=j;
                        k2=i;
                    }

                 }
                 System.out.println("年龄最大："+Personlist1.get(k1));
                 System.out.println("年龄最小："+Personlist1.get(k2));
                 break;
             case 3:
                 System.out.println("place?");
                 String find = scanner.next();
                 String place=find.substring(0,3);
                 String place2=find.substring(0,3);
                 for (int i = 0; i <Personlist1.size(); i++)
                 {
                     if(Personlist1.get(i).getbirthplace().substring(1,4).equals(place))
                     {
                         System.out.println("你的同乡："+Personlist1.get(i));
                     }
                 } 

                 break;
             case 4:
                 System.out.println("年龄：");
                 int yourage = scanner.nextInt();
                 int close=ageclose(yourage);
                 int d_value=yourage-Personlist1.get(close).getage();
                 System.out.println(""+Personlist1.get(close));

                 break;
             case 5:
            isTrue = false;
            System.out.println("再见!");
                 break;
             default:
                 System.out.println("输入有误");
             }
         }
     }
     public static int ageclose(int age) {
            int m=0;
         int    max=53;
         int d_value=0;
         int k=0;
         for (int i = 0; i < Personlist1.size(); i++)
         {
             d_value=Personlist1.get(i).getage()-age;
             if(d_value<0) d_value=-d_value;
             if (d_value<max)
             {
                max=d_value;
                k=i;
             }

          }    return k;

      }

 }

Main

 package Second;

 //jiekouwenjiaan

 public class Person implements Comparable<Person> {
   private String name;
   private String id;
   private int age;
   private String sex;
   private String birthplace;

 public String getname() {
 return name;
 }
 public void setname(String name) {
 this.name = name;
 }
 public String getid() {
 return id;
 }
 public void setid(String id) {
 this.id= id;
 }
 public int getage() {

 return age;
 }
 public void setage(int age) {
 //int a = Integer.parseInt(age);
 this.age= age;
 }
 public String getsex() {
 return sex;
 }
 public void setsex(String sex) {
 this.sex= sex;
 }
 public String getbirthplace() {
 return birthplace;
 }
 public void setbirthplace(String birthplace) {
 this.birthplace= birthplace;
 }

 public int compareTo(Person o) {
 return this.name.compareTo(o.getname());

 }

 public String toString() {
 return  name+"\t"+sex+"\t"+age+"\t"+id+"\t";

 }

 }

Person

（4）合作实验十编程练习2

 package A;

 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.Scanner;
 public class Main {

     public static void main(String[] args) {
                 Scanner in = new Scanner(System.in);
                 counter min=new counter();
                 PrintWriter out = null;
                 try {
                     out = new PrintWriter("result.txt");
                     int sum = 0;
                     for (int i = 1; i <=10; i++) {
                         int a = (int) Math.round(Math.random() * 100);
                         int b = (int) Math.round(Math.random() * 100);
                         int menu = (int) Math.round(Math.random() * 3);
                         switch (menu) {
                         case 0:
                             System.out.println(i+":"+a + "+" + b + "=");
                             int c1 = in.nextInt();
                             out.println(a + "+" + b + "=" + c1);
                             if (c1 == (a + b)) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }
                             break;
                         case 1:
                             while (a < b) {
                                 b = (int) Math.round(Math.random() * 100);
                             }
                             System.out.println(i+":"+a + "-" + b + "=");
                             int c2 = in.nextInt();
                             out.println(a + "-" + b + "=" + c2);
                             if (c2 == (a - b)) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         case 2:
                             System.out.println(i+":"+a + "*" + b + "=");
                             int c3 = in.nextInt();
                             out.println(a + "*" + b + "=" + c3);
                             if (c3 == a * b) {
                                 sum += 10;
                                 System.out.println("恭喜答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         case 3:
                              while(b == 0){
                                     b = (int) Math.round(Math.random() * 100);
                                 }
                                 while(a % b != 0){
                                     a = (int) Math.round(Math.random() * 100);

                                 }
                             System.out.println(i+":"+a + "/" + b + "=");
                             int c4 = in.nextInt();
                             if (c4 == a / b) {
                                 sum += 10;
                                 System.out.println("恭喜，答案正确");
                             } else {
                                 System.out.println("抱歉，答案错误");
                             }

                             break;
                         }
                     }
                     System.out.println("你的得分为" + sum);
                     out.println("你的得分为" + sum);
                     out.close();
                 } catch (FileNotFoundException e) {
                     e.printStackTrace();
                 }
             }
         }

Main

 package A;

 public class counter<T> {
     private T a;
     private T b;
     public counter() {
         a=null;
         b=null;
     }
     public counter(T a,T b) {
         this.a=a;
         this.b=b;
     }
     public int count1(int a,int b) {
         return a+b;
     }
     public int count2(int a,int b) {
         return a-b;
     }
     public int count3(int a,int b) {
         return a*b;
     }
     public int count4(int a,int b) {
         return a/b;
     }
 }

counter

---

第三部分：总结

1.没有看清楚题目就粗心地在Elipse环境下调试了所有程序，对于命令行交作业时才发现，这一直是我的一大缺点，如影随形，不离不弃，关于还有很多问题不懂；

2.另外本周我的学习表现整体不是很良好，总感觉知识没消化掉，还有种要被“噎死”的感觉；

3.本周的学习特色是末尾的合作部分，这让我感到有趣且愉快，我的伙伴常惠琢很默契，不需多解释，但我有时更期待思维碰撞激烈的火花 ♦♦♦；