201771010126 王燕《面向对象程序设计（java）》第十一周学习总结

实验十一   集合

实验时间 2018-11-8

1、实验目的与要求

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

Vector类实现了长度可变的数组。 Vector中只能存放对象。 Vector的元素通过下标进行访问。

Vector类关键属性：

　　 capacity表示集合最多能容纳的元素个数。

　　 capacityIncrement表示每次增加多少容量。

　　 size表示集合当前元素个数。

Vector类的关键方法：

　　void addElement(Object obj)

　　void add(int index, Object element)

　　Object elementAt(int index)

　　void insertElementAt(Object obj, int index)

Stack类是Vector的子类。 Stack类描述堆栈数据结构，即LIFO。 Stack类的关键方法：

　　 public void push(Object item)：把项压入栈顶

　　public Object pop()：移除栈顶对象并作为此函数的值返回该对象的值

　　 public Object peek()：查看栈顶对象但不移除

　　 public boolean empty()：测试堆栈是否为空

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

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

集合框架为程序员提供了一个功能强大的设计方案以解决编程过程中面临的大多数任务。下一次当你需要存储和检索信息时，可考虑使用类集。记住，类集不仅仅是专为那些“大型作业”，例如联合数据库，邮件列表或产品清单系统等所专用的。它们对于一些小型作业也是很有效的。例如，TreeMap可以给出一个很好的类集以保留一组文件的字典结构。TreeSet在存储工程管理信息时是十分有用的。坦白地说，对于采用基于类集的解决方案而受益的问题种类只受限于你的想象力。

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

ArrayList内存中是顺序存储的。

LinkedList内存中是以链表方式存储的。

将线性表中的数据元素依次存放在某个存储区域中,所形成的表称为顺序表。一维数组就是用顺序方式存储的线性表。

ArrayList封装了一个动态再分配的对象数组，主要构造器和方法有：

　　 public ArrayList()

　　public ArrayList(int initialCapacity)

　　public ArrayList(Collection<? extends E> elements)

　　public void trimToSize()

LinkedList<E>类的API：

　　public LinkedList()

　　public LinkedList(Collection<? extends E> elements)

　　public void addFirst(E element)

　　public void addLast(E element)

　　public E getFirst()

　　public E getLast()

　　public E removeFirst()

　　public E removeLast()

ArrayList底层采用数组完成，而LinkedList则是以一般的双向链表(double-linked list)完成，其内每个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素。 如果我们经常在List的开始处增加元素，或者在List中进行插入和删除操作，我们应该使用LinkedList，否则的话，使用ArrayList将更加快速。

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

HashSet扩展AbstractSet并且实现Set接口。它创建一个使用散列表存储的集合。散列表（hash table）是通过使用称为散列法的机制来存储信息的。在散列法中，键的信息内容用于确定一个唯一的值，称为它的散列码。然后散列码作为与键相关的数据存储之处的索引使用。键到它的散列码的转化是自动完成的，我们不会看到散列码本身，同样，散列码也不能直接索引散列表。

散列集的构造方法： public HashSet() public HashSet(int initialCapacity) public HashSet(int initialCapacity,float loadFactor) public HashSet(Collection<? extends E> elements)

TreeSet类的底层结构为树的一种有序的Set。对象以升序顺序存储，访问和遍历它的时间很快，这使得TreeSet成为存储大量必须能很快查找的排序信息的很好选择。 TreeSet类的构造方法： public TreeSet() public TreeSet(Collection<? extends E> elements) public TreeSet(Comparator<? super E> elements) public TreeSet(SortedSet<E> elements) HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

在默认情况下，树集假定插入的元素实现了Comparable接口。这个接口定义了一个方法： public interface Comparable<T> { int compareTo(T other); } 如果要插入自定义的对象，就必须通过实现Comparable接口自定义排序顺序。在Object类中，没有提供任何compareTo接口的默认实现。 class Item implements Comparable<Item> { public int compareTo(Item other){ …} }

由于使用Compareble接口定义排序的局限性（p367）。可以通过将Comparator对象传递给 TreeSort构造器来告诉树集使用不同的比较方法，从而允许在排序顺序上实现精确控制。 Comparator接口声明了一个带有两个显式参数的compare方法： public interface Comparator<T> { int compare(T a，T b); }

如果按照描述信息进行排序，就直接定义一个实现Comparator接口的类： Class ItemComparator implements Comparator<Item> { public int compare(Item a，Item b) { String descrA = a.getDescription(); String descrB = b.getDescription(); return descrA.compareTo(descrB); } } ItemComparator comp = new ItemComparator(); SortedSet<Item> sortByDescription = new TreeSet<>(comp);

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

Map接口用来维持很多“键－值”对，以便通过键来查找相应的值。

HashMap基于散列表实现（替代Hashtable）。

HashMap是一个基于散列表完成的一个实现类，可以用它来取代Hashtable。 HashMap类的构造器： public HashMap() public HashMap(int initialCapacity) public HashMap(int initialCapacity, float loadFactor) public HashMap(Map<? extends K,? extends V> m)

TreeMap在一个二叉树的基础上实现。

TreeMap是底层基于树完成的一个Map。

当我们遍历它时，会以排序形式出现，次序由Comparable或Comparator比较器决定。 TreeMap类的构造器： public TreeMap() public TreeMap(Map<? extends K,? extends V> m) public TreeMap(Comparator<? super K> c) public TreeMap(SortedMap<K,? extends V> m)

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

2、实验内容和步骤

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

测试程序1：

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

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

 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++) {
             if(cats.elementAt(i) instanceof Cat)
             {
                 ((Cat) cats.elementAt(i)).print();
             }
             else
             {
                 ((Dog) cats.elementAt(i)).print();}
             }
     }
 }

 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());
     }
 }

 import java.util.*;

 class Counter {
     int i = 1;//不加任何访问权限修饰符，缺省的是friendly

     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++) {//生成10000个随机的r（value）值，做循环
             Integer r = new Integer((int) (Math.random() * 20));//在0~20以内随机生成一个整形数据（键值），Integer是整形包装器
             if (ht.containsKey(r))//判断containsKey的键值
                 ((Counter) ht.get(r)).i++;//Counter类对象直接引用属性，get方法获得value值
             else
                 ht.put(r, new Counter());//出现重复数据
         }
         System.out.println(ht);
     }
 }

//示例程序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);

}

}

测试程序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");

}

}

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

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

 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();//一开始迭代器(Iterator)在所有元素的左边，调用next()之后，迭代器移到第一个和第二个元素之间，next()方法返回迭代器刚刚经过的元素。

       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());

}

}

}

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

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

 package Set;

 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.");
    }
 }

 package treeSet;

 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);
    }
 }

 package treeSet;

 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);
    }
 }

测试程序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 map;

 /**
  * 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 + "]";
    }
 }

 package map;

 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));
    }
 }

实验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，结合使用体验对所运行程序提出完善建议；

 package 小陈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 Identity{
     private static ArrayList<Student> studentlist;
     public static void main(String[] args) {
         studentlist = new ArrayList<>();
         Scanner scanner = new Scanner(System.in);
         File file = new File("G:\\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("0.退出");
             int status = scanner.nextInt();
             switch (status) {
             case :
                 Collections.sort(studentlist);
                 System.out.println(studentlist.toString());
                 break;
             case :
                  int max=,min=;
                  int j,k1 = ,k2=;
                  for(int i=;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 :
                  System.out.println("老家?");
                  String find = scanner.next();
                  String place=find.substring(,);
                  for (int i = ; i <studentlist.size(); i++)
                  {
                      if(studentlist.get(i).getprovince().substring(,).equals(place))
                          System.out.println("老乡"+studentlist.get(i));
                  }
                  break;

             case :
                 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 :
                     status = ;
                     System.out.println("程序已退出!");
                     break;
                default:
                    System.out.println("输入错误");
                }
              }
             }
         public static int agenear(int age) {
         int min=,value=,k=;
          for (int i = ; i < studentlist.size(); i++)
          {
              value=studentlist.get(i).getage()-age;
              if(value<) value=-value;
              if (value<min)
              {
                 min=value;
                 k=i;
              }
           }
          return k;
       }

 }

 package 小陈1;

 public  class Student implements Comparable<Student> {
     private    String name;//定义局部变量name,number,sex,age,province
     private    String number ;
     private    String sex ;
     private    int age;
     private    String province;

     public String getName() {//定义构造方法
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getnumber() {
         return number;
     }
     public void setnumber(String number) {
         this.number = number;
     }
     public String getsex() {
         return sex ;
     }
     public void setsex(String sex ) {
         this.sex =sex ;
     }
     public int getage() {
         return age;
     }
     public void setage(int age ) {
         this.age=age ;
     }
     public String getprovince() {
         return province;
     }
     public void setprovince(String province) {
         this.province=province ;
     }
 @Override
 public int compareTo(Student other) {
     // TODO Auto-generated method stub
      return this.name.compareTo(other.getName());
 }

 public String toString() {
     return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
 }
 }

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

 package 小陈1;

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

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

         Scanner in = new Scanner(System.in);
         Pair student=new Pair();
         PrintWriter out = null;
        try {//捕获异常
            out = new PrintWriter("text.txt");//讲程序所出题目以及用户作答用文档形式保存在txt文档中
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         }
         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 c= (int) Math.round(Math.random() * 3);//随机生成一个三以内的数字，并为随机产生的数字匹配相应的运算类型

            switch(c)//使用switch语句做四则运算
            {
            case 0:
                System.out.println(i+": "+a+"/"+b+"=");

                while(b==0)
                {
                    b = (int) Math.round(Math.random() * 100);
             }

             int C = in.nextInt();
             out.println(a+"/"+b+"="+C);
             if (C == student.division(a, b)) {
                 sum += 10;
                 System.out.println("right");
             }
             else {
                 System.out.println("false");
             }

             break;

            case 1:
                System.out.println(i+": "+a+"*"+b+"=");
                int D = in.nextInt();
                out.println(a+"*"+b+"="+D);
                if (D == student.multiply(a, b)) {
                    sum += 10;
                    System.out.println("right");
                }
                else {
                    System.out.println("false");
                }
                break;
            case 2:
                System.out.println(i+": "+a+"+"+b+"=");
                int E = in.nextInt();
                out.println(a+"+"+b+"="+E);
                if (E == student.plus(a, b)) {
                    sum += 10;
                    System.out.println("right");
                }
                else {
                    System.out.println("false");
                }

                break ;
            case 3:
                System.out.println(i+": "+a+"-"+b+"=");
                int F = in.nextInt();
                out.println(a+"-"+b+"="+F);
                if (F == student.minus(a, b)) {
                    sum += 10;
                    System.out.println("right");
                }
                else {
                    System.out.println("false");
                }
                break ;
               }
           }//生成四则运算题目，并判断回答是否正确
        System.out.println("成绩"+sum);
         out.println("成绩:"+sum);
          out.close();
    }
    }

 package 小陈1;

 public class Pair<T> {
        private T a;//创建局部变量a和b
        private T b;
         public Pair()
         {
             a = null;
             b = null;
         }
         public Pair(T a,T b)
         {
             this.a = a;
             this.b = b;
         }
         public T getA()
         {
             return a;
         }
         public T getB()
         {
             return b;
         }
        public int plus(int a,int b)//加法运算的构造方法
        {
            return a+b;
        }
        public int minus(int a,int b)//减法运算的构造方法
        {
            return a-b;
        }
        public int multiply(int a,int b)//乘法运算的构造方法
        {
            return a*b;
        }
        public int division(int a,int b)//除法法运算的构造方法
        {
            if(b!=0 && a%b==0)
                return a/b;
            else
                return 0;
        }

 }

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

 package 看到谁;
 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 import java.util.Scanner;
 public class Caculator {
     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         Caculator1 computing=new Caculator1();
         PrintWriter output = null;
         //使用了异常处理机制，增强代码的安全性
         try {
             output = new PrintWriter("Caculator.txt");
         } catch (Exception e) {
         }
         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 s = (int) Math.round(Math.random() * 3);
             //选择所要进行的操作
         switch(s)//s为随机数，可随机执行下面四种操作
         {
            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);
                //修改建议:生成除法题目时，对a，b两个数进行条件判断，确保整除，还有除数不为0
                if (c == (double)computing.division(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break;
             //
            case 2:
                System.out.println(i+": "+a+"*"+b+"=");
                int c1 = in.nextInt();
                output.println(a+"*"+b+"="+c1);
                if (c1 == computing.multiplication(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break;
            case 3:
                System.out.println(i+": "+a+"+"+b+"=");
                int c2 = in.nextInt();
                output.println(a+"+"+b+"="+c2);
                if (c2 == computing.addition(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break ;
            case 4:
                System.out.println(i+": "+a+"-"+b+"=");
                int c3 = in.nextInt();
                output.println(a+"-"+b+"="+c3);
                if (c3 == computing.subtraction(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break ;

                } 

           }
         System.out.println("scores："+sum);
         output.println("scores："+sum);
         output.close();

     }
 }
 class Caculator1
 {
        private int a;
        private int b;
         public int  addition(int a,int b)
         {
             return a+b;
         }
         public int  subtraction(int a,int b)
         {
             if((a-b)<0)
                 return 0;
             else
             return a-b;
         }
         public int   multiplication(int a,int b)
         {
             return a*b;
         }
         public int   division(int a,int b)
         {
             if(b!=0)
             return a/b;
             else
         return 0;
         }

 }

 四则运算

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

 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 Identity{
     private static ArrayList<Student> studentlist;
     public static void main(String[] args) {
         studentlist = new ArrayList<>();
         Scanner scanner = new Scanner(System.in);
         File file = new File("C:/身份证号.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("0.退出");
             int status = scanner.nextInt();
             switch (status) {
             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 0:
                     status = 0;
                     System.out.println("程序已退出!");
                     break;
                default:
                    System.out.println("输入错误");
                }
              }
             }
         public static int agenear(int age) {
         int min=53,value=0,k=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;
                 k=i;
              }
           }
          return k;
       }

 }

 Identity

 package 看到谁;

 public  class Student implements Comparable<Student> {
     private    String name;
     private    String number ;
     private    String sex ;
     private    int age;
     private    String province;

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getnumber() {
         return number;
     }
     public void setnumber(String number) {
         this.number = number;
     }
     public String getsex() {
         return sex ;
     }
     public void setsex(String sex ) {
         this.sex =sex ;
     }
     public int getage() {
         return age;
     }
     public void setage(int age ) {
         this.age=age ;
     }
     public String getprovince() {
         return province;
     }
     public void setprovince(String province) {
         this.province=province ;
     }
 @Override
 public int compareTo(Student other) {
     // TODO Auto-generated method stub
      return this.name.compareTo(other.getName());
 }

 public String toString() {
     return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
 }
 }

 Student

实验总结：这一周结合上一周的血洗对于异常类的处理有了进一步的掌握，通过对之前实验的修改以及总结，还有同学间的合作扛到了很多自己的不足，和同学之间合作修改程序，对程序中自己觉察不到的bug再同学的建议下作了修改是的程序更加完整。