201771010111李瑞红《第十一周学习总结》

 

 

实验十一   集合

实验时间 2018-11-8

第一部分：理论总结

1.栈(Stack)也是一种特殊的线性表，是一种后进先出 (LIFO)的结构。栈是限定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶(top)，表头称为(bottom)。栈的物理存储可以用顺序存储结构，也可以用链式存储结构。

2.队列(Queue)是限定所有的插入只能在表的一端进行 ，而所有的删除都在表的另一端进行的线性表。表中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。队列的操作是按先进先出(FIFO)的原则进行的。队列的物理存储可以用顺序存储结构，也可以用链式存储结构。

3.一般将数据结构分为两大类：线性数据结构和非线性数据结构。线性数据结构：线性表、栈、队列、串、数组和文件。非线性数据结构：树和图。线性表按其存储结构可分为顺序表和链表；用顺序存储结构存储的线性表称为顺序表；顺序表将线性表中的数据元素依次存放在某个存储区域中。一维数组就是用顺序方式存储的线性表。用链式存储结构存储的线性表称为链表。

4.集合框架：JAVA集合类库的统一架构。集合类的作用：Java的集合类提供了一些基本数据结构的支持。集合类的使用： Java的集合类包含在java.util包中。集合类的特点一：只容纳对象。注意：数组可以容纳基本数据类型数据和对象。如果集合类中想使用基本数据类型，又想利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理。特点二：集合类容纳的对象都是Object类的实例，一旦把一个对象置入集合类中，它的类信息将丢失，这样设计的目的是为了集合类的通用性。因为Object类是所有类的祖先，所以可以在这些集合中存放任何类的对象而不受限制，但在使用集合成员之前必须对它重新造型。

5.JAVA的集合框架实现对各种数据结构的封装，以降低对数据管理与处理的难度。所谓框架就是一个类库的集合，框架中包含很多超类，编程者创建这些超类的子类可较方便的设计设计程序所需的类。

6.Map接口用来维持很多“键－值”对，以便通过键来查找相应的值。HashMap基于散列表实现（替代Hashtable）。TreeMap在一个二叉树的基础上实现（map）是一个存储关键字和值的关联或关键字/值对的对象。给定一个关键字，可以得到它的值。关键字和值都是对象。关键字必须是唯一的。但值是可以被复制的。Map接口映射唯一关键字到值。关键字（key）是以后用于检索值的对象。给定一个关键字和一个值，可以存储这个值到一个Map对象中。当这个值被存储以后，就可以使用它的关键字来检索它，Map循环使用两个基本操作：get( )和put( )。使用 put( )方法可以将一个指定了关键字和值的值加入映射。为了得到值可以通过将关键字作为参数来调用 get( )方法。调用返回该值。Map接口的实现类主要有HashMap，TreeMap，Hashtable，Properties。HashMap对key进行散TreeMap按照key进行排序。和Set类似，HashMap的速度通常都比TreeMap快，只有在需要排序的功能的时候，才使用TreeMap。

7.Vector类类似长度可变的数组。Vector中只能存放对象。Vector的元素通过下标进行访问。 Vector类关键属性：capacity表示集合最多能容纳的元素个数。capacityIncrement表示每次增加多少容量。size表示集合当前元素个数。Stack类是Vector的子类。Stack类描述堆栈数据结构，即LIFO。Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。

8.集合框架中的基本接口：Collection：集合层次中的根接口，JDK未提供这个接口的直接实现类。

Set：不能包含重复的元素。对象可能不是按存放的次序存放，也就是说不能像数组一样按索引的方式进行访问，SortedSet是一个按照升序排列元素的Set。List的明显特征是它的元素都有一个确定的顺序。实现它的类有ArrayList和LinkedList。ArrayList中的元素在内存中是顺序存储的。LinkedList中的元素在内存中是以链表方式存储的。

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

第二部分：实验

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

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

}

}

运行结果

改进程序

package ccc;

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

结果

 示例2：

原程序：

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

   }

}

结果：

实例三

import java.util.*;

class Counter {
    int i = 1;
    public String toString() {
        return Integer.toString(i);//将i转换成tostring类
    }
}
public class Statistics {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();//生成Hashtable类
        for (int i = 0; i < 10000; i++) {
            Integer r = new Integer((int) (Math.random() * 20));//用Math.random生成20以内的随机数
            if (ht.containsKey(r))//通过ht对象调用containsKey方法
                ((Counter) ht.get(r)).i++;//通过Counter类对象引用它的属性
            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");

   }

}

源代码

package ccc;
import java.util.*;
public class ArrayListDemo {
public static void main(String[] argv) {
ArrayList<Comparable> al = new ArrayList();
// 给Arraylist里面添加元素
al.add(new Integer(11));
al.add(new Integer(12));
al.add(new Integer(13));
al.add(new String("hello"));
// 通过for循环打印输出
System.out.println(al.size());

System.out.println("Retrieving by index:");
for (int i = 0; i<al.size(); i++) {
System.out.println("Element " + i + " = " + al.get(i));
}
}
}

实验结果

源代码

package ccc;
import java.util.*;
public class LinkedListDemo {
    public static void main(String[] argv) {
        LinkedList l = new LinkedList();
        l.add(new Object());//调用LinkedList的add方法
        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)
   {
       //创建a和b两个链表
      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");

      //合并a和b中的词

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

      //从第二个链表中每隔一个元素删除一个元素

      bIter = b.iterator();
      while (bIter.hasNext())
      {
         bIter.next(); // 移动一个元素
         if (bIter.hasNext())
         {
            bIter.next(); // 移动下一个元素
            bIter.remove(); // 删除元素
         }
      }

      System.out.println(b);


      a.removeAll(b);

      System.out.println(a);//通过AbstractCollection类中的toString方法打印出链表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());

        }

    }

}

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"); // 复制
        h.add("Three");
        Iterator it = h.iterator();
        while (it.hasNext()) {
             System.out.println(it.next());
        }
    }
}

 

l  在Elipse环境下调试教材365页程序9-2，结合运行结果理解程序；了解HashSet类的用途及常用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<>(); // 对哈希表进行设置
        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。

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

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));//把自定义类对象存入TreeSet进行排序

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

测试程序4：

  使用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);

  }

}

 

import java.util.*;
public class HashMapDemo //基于哈希表的 Map接口的实现，提供所有可选的映射操作
{
   public static void main(String[] argv) {
      HashMap h = new HashMap();
      // 哈希映射从公司名称到地址
      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);
  }
}

 

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

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

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

      // 打印所有条目

      System.out.println(staff);

      // 删除一个条目

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

      // 替换一个条目

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

      // 查找一个值

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

      // 遍历所有条目

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

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

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

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.Scanner;
import java.util.Collections;//对集合进行排序、查找、修改等；

public class Test {
    private static ArrayList<Citizen> citizenlist;

    public static void main(String[] args) {
        citizenlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("E:/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 id = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String birthplace = linescanner.nextLine();
                Citizen citizen = new Citizen();
                citizen.setName(name);
                citizen.setId(id);
                citizen.setSex(sex);
                // 将字符串转换成10进制数
                int ag = Integer.parseInt(age);
                citizen.setage(ag);
                citizen.setBirthplace(birthplace);
                citizenlist.add(citizen);

            }
        } catch (FileNotFoundException e) {
            System.out.println("信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {

            System.out.println("1.按姓名字典序输出人员信息");
            System.out.println("2.查询最大年龄的人员信息、查询最小年龄人员信息");
            System.out.println("3.查询人员中是否查询人员中是否有你的同乡");
            System.out.println("4.输入你的年龄，查询文件中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
            System.out.println("5.退出");
            int nextInt = scanner.nextInt();
            switch (nextInt) {
            case 1:
                Collections.sort(citizenlist);
                System.out.println(citizenlist.toString());
                break;
            case 2:
                int max = 0, min = 100;
                int m, k1 = 0, k2 = 0;
                for (int i = 1; i < citizenlist.size(); i++) {
                    m = citizenlist.get(i).getage();
                    if (m > max) {
                        max = m;
                        k1 = i;
                    }
                    if (m < min) {
                        min = m;
                        k2 = i;
                    }
                }
                System.out.println("年龄最大：" + citizenlist.get(k1));
                System.out.println("年龄最小：" + citizenlist.get(k2));
                break;
            case 3:
                System.out.println("出生地：");
                String find = scanner.next();
                String place = find.substring(0, 3);
                for (int i = 0; i < citizenlist.size(); i++) {
                    if (citizenlist.get(i).getBirthplace().substring(1, 4).equals(place))
                        System.out.println("出生地" + citizenlist.get(i));
                }
                break;
            case 4:
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near = peer(yourage);
                int j = yourage - citizenlist.get(near).getage();
                System.out.println("" + citizenlist.get(near));
                break;
            case 5:
                isTrue = false;
                System.out.println("程序已退出!");
                break;
            default:
                System.out.println("输入有误");
            }
        }
    }

    public static int peer(int age) {
        int flag = 0;
        int min = 53, j = 0;
        for (int i = 0; i < citizenlist.size(); i++) {
            j = citizenlist.get(i).getage() - age;
            if (j < 0)
                j = -j;
            if (j < min) {
                min = j;
                flag = i;
            }
        }
        return flag;
    }
}

public class Citizen implements Comparable<Citizen> {

    private String name;
    private String id;
    private String sex;
    private int age;
    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 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 getBirthplace() {
        return birthplace;
    }

    public void setBirthplace(String birthplace) {
        this.birthplace = birthplace;
    }

    public int compareTo(Citizen other) {
        return this.name.compareTo(other.getName());
    }

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

实验结果

 

实验十

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

/*
 * 该程序用来随机生成0到100以内的加减乘除题
 */
public class Demo {
    public static void main(String[] args) {
        // 用户的答案要从键盘输入，因此需要一个键盘输入流
        Scanner in = new Scanner(System.in);
        Counter counter = new Counter();
        PrintWriter out = null;
        try {
            out = new PrintWriter("text.txt");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 定义一个变量用来统计得分
        int sum = 0;
        int k = 0;
        // 通过循环生成10道题
        for (int i = 0; i < 10; i++) {

            // 随机生成两个100以内的随机数作加减乘除
            int a = (int) Math.round(Math.random() * 100);
            int b = (int) Math.round(Math.random() * 100);
            int d = (int) Math.round(Math.random() * 3);

            switch (d) {

            case 0:
                if (a % b == 0) {
                    System.out.println(a + "/" + b + "=");
                    break;
                }
                 int c = in.nextInt();
                 out.println(a + "/" + b + "="+c);
            case 1:
                System.out.println(a + "*" + b + "=");
                 int c1 = in.nextInt();
                 out.println(a + "*" + b + "="+c1);
                break;
            case 2:
                System.out.println(a + "+" + b + "=");
                 int c2 = in.nextInt();
                 out.println(a + "+" + b + "="+c2);
                break;
            case 3:
                if (a > b) {
                    System.out.println(a + "-" + b + "=");
                    break;
                }
                 int c3 = in.nextInt();
               out.println(a + "-" + b + "="+c3);

            }

            // 定义一个整数用来接收用户输入的答案
            double c = in.nextDouble();

            // 判断用户输入的答案是否正确，正确给10分，错误不给分
            if (c == a / b | c == a * b | c == a + b | c == a - b) {
                sum += 10;
                System.out.println("恭喜答案正确");
            } else {
                System.out.println("抱歉，答案错误");

            }
            out.println(a + "/" + b + "=" + c);
            out.println(a + "*" + b + "=" + c);
            out.println(a + "+" + b + "=" + c);
            out.println(a + "-" + b + "=" + c);

        }
        // 输出用户的成绩
        System.out.println("你的得分为" + sum);

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

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

    public int add(int a, int b) {
        return a + b;
    }

    public int reduce(int a, int b) {
        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;
    }

}

 小伙伴：狄慧

通过结对实验，对互相存在的问题进行了解决，通过学习交流，对问题的看法有了不一样的切入点。结对编程，极大的提高了我们的编程兴趣，和编程效率，是一种很好的编程方式。通过学习交流，对问题的看法有了不一样的切入点。

实验总结：

1.Vector类类似长度可变的数组。Vector中只能存放对象。Vector的元素通过下标进行访问。 Vector类关键属性：capacity表示集合最多能容纳的元素个数。capacityIncrement表示每次增加多少容量。size表示集合当前元素个数。Stack类是Vector的子类。Stack类描述堆栈数据结构，即LIFO。Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。

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

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

感受：

本次实验不同于以往，采用结对编程，通过这种编程方式，对于有些个人能力限制及思考不到的问题，同伴之间的合作会产生更好的效果，在交流中不同的思维方式会产生不同角度的思考，并相互借鉴对方比较新颖的思路，对于解决问题更有效果。通过本周的学习我了解了新旧集合类的不同， 掌握了Vetor、StacHashtable三个类的用途， 对于HashSet类、TreeSet类的用途以及HashMap、TreeMap两个类的用途尚且理解不是很到位，在后面的学习中应该进行再理解。