201771010111李瑞紅《第十一週學習總結》

時間 2019-11-11

標籤第十一週學習總結简体版

原文原文鏈接

實驗十一 集合html

實驗時間 2018-11-8java

第一部分：理論總結算法

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。dom

7.Vector類相似長度可變的數組。Vector中只能存放對象。Vector的元素經過下標進行訪問。 Vector類關鍵屬性：capacity表示集合最多能容納的元素個數。capacityIncrement表示每次增長多少容量。size表示集合當前元素個數。Stack類是Vector的子類。Stack類描述堆棧數據結構，即LIFO。Hashtable經過鍵來查找元素。Hashtable用散列碼（hashcode）來肯定鍵。全部對象都有一個散列碼，能夠經過Object類的hashCode()方法得到。oop

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 //示例程序1
 2 
 3 import java.util.Vector;
 4 
 5  
 6 
 7 class Cat {
 8 
 9 private int catNumber;
10 
11  
12 
13 Cat(int i) {
14 
15         catNumber = i;
16 
17 }
18 
19  
20 
21 void print() {
22 
23         System.out.println("Cat #" + catNumber);
24 
25 }
26 
27 }
28 
29  
30 
31 class Dog {
32 
33 private int dogNumber;
34 
35  
36 
37 Dog(int i) {
38 
39         dogNumber = i;
40 
41 }
42 
43  
44 
45 void print() {
46 
47         System.out.println("Dog #" + dogNumber);
48 
49 }
50 
51 }
52 
53  
54 
55 public class CatsAndDogs {
56 
57 public static void main(String[] args) {
58 
59         Vector cats = new Vector();
60 
61         for (int i = 0; i < 7; i++)
62 
63                cats.addElement(new Cat(i));
64 
65         cats.addElement(new Dog(7));
66 
67         for (int i = 0; i < cats.size(); i++)
68 
69                ((Cat) cats.elementAt(i)).print();
70 
71 }
72 
73 }

運行結果

改進程序

 1 package ccc;
 2 
 3     import java.util.Vector;
 4 
 5     class Cat {
 6         private int catNumber;
 7 
 8         Cat(int i) {
 9             catNumber = i;
10         }
11 
12         void print() {
13             System.out.println("Cat #" + catNumber);
14         }
15     }
16 
17     class Dog {
18         private int dogNumber;
19 
20         Dog(int i) {
21             dogNumber = i;
22         }
23 
24         void print() {
25             System.out.println("Dog #" + dogNumber);
26         }
27     }
28 
29     public class CatsAndDogs {
30         public static void main(String[] args) {
31             Vector cats = new Vector();
32             for (int i = 0; i < 7; i++)
33                 cats.addElement(new Cat(i));
34             cats.addElement(new Dog(7));
35             for (int i = 0; i < cats.size(); i++) {
36                 if(cats.elementAt(i) instanceof Cat) {
37                  ( (Cat) cats.elementAt(i)).print();
38             }else {
39                 ((Dog)cats.elementAt(i)).print();
40             }
41             }
42         }
43     }
44

結果

示例2：

原程序：

 1 //示例程序2
 2 
 3 import java.util.*;
 4 
 5  
 6 
 7 public class Stacks {
 8 
 9    static String[] months = { "1", "2", "3", "4" };
10 
11  
12 
13    public static void main(String[] args) {
14 
15       Stack stk = new Stack();
16 
17       for (int i = 0; i < months.length; i++)
18 
19          stk.push(months[i]);
20 
21       System.out.println(stk);
22 
23       System.out.println("element 2=" + stk.elementAt(2));
24 
25       while (!stk.empty())
26 
27          System.out.println(stk.pop());
28 
29    }
30 
31 }

結果：

實例三

 1 import java.util.*;
 2 
 3 class Counter {
 4     int i = 1;
 5     public String toString() {
 6         return Integer.toString(i);//將i轉換成tostring類
 7     }
 8 }
 9 public class Statistics {
10     public static void main(String[] args) {
11         Hashtable ht = new Hashtable();//生成Hashtable類
12         for (int i = 0; i < 10000; i++) {
13             Integer r = new Integer((int) (Math.random() * 20));//用Math.random生成20之內的隨機數
14             if (ht.containsKey(r))//經過ht對象調用containsKey方法
15                 ((Counter) ht.get(r)).i++;//經過Counter類對象引用它的屬性
16             else
17                 ht.put(r, new Counter());
18         }
19         System.out.println(ht);
20     }
21 }

測試程序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 package ccc;
 2 import java.util.*;
 3 public class ArrayListDemo {
 4 public static void main(String[] argv) {
 5 ArrayList<Comparable> al = new ArrayList();
 6 // 給Arraylist裏面添加元素
 7 al.add(new Integer(11));
 8 al.add(new Integer(12));
 9 al.add(new Integer(13));
10 al.add(new String("hello"));
11 // 經過for循環打印輸出
12 System.out.println(al.size());
13 
14 System.out.println("Retrieving by index:");
15 for (int i = 0; i<al.size(); i++) {
16 System.out.println("Element " + i + " = " + al.get(i));
17 }
18 }
19 }

實驗結果

源代碼

 1 package ccc;
 2 import java.util.*;
 3 public class LinkedListDemo {
 4     public static void main(String[] argv) {
 5         LinkedList l = new LinkedList();
 6         l.add(new Object());//調用LinkedList的add方法
 7         l.add("Hello");
 8         l.add("zhangsan");
 9         ListIterator li = l.listIterator(0);//
10         while (li.hasNext())
11             System.out.println(li.next());
12         if (l.indexOf("Hello") < 0)//判斷元素是否在集合中 
13             System.err.println("Lookup does not work");
14         else
15             System.err.println("Lookup works");
16    }
17 }

實驗結果

l 在Elipse環境下編輯運行調試教材360頁程序9-1，結合程序運行結果理解程序；

l 掌握ArrayList、LinkList兩個類的用途及經常使用API。

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates operations on linked lists.
 5  * @version 1.11 2012-01-26
 6  * @author Cay Horstmann
 7  */
 8 public class LinkedListTest
 9 {
10    public static void main(String[] args)
11    {
12        //建立a和b兩個鏈表
13       List<String> a = new LinkedList<>();//泛型
14       a.add("Amy");
15       a.add("Carl");
16       a.add("Erica");
17 
18       List<String> b = new LinkedList<>();//泛型
19       b.add("Bob");
20       b.add("Doug");
21       b.add("Frances");
22       b.add("Gloria");
23 
24       //合併a和b中的詞
25 
26       ListIterator<String> aIter = a.listIterator();
27       Iterator<String> bIter = b.iterator();
28 
29       while (bIter.hasNext())
30       {
31          if (aIter.hasNext()) aIter.next();
32          aIter.add(bIter.next());
33       }
34 
35       System.out.println(a);
36 
37       //從第二個鏈表中每隔一個元素刪除一個元素
38 
39       bIter = b.iterator();
40       while (bIter.hasNext())
41       {
42          bIter.next(); // 移動一個元素
43          if (bIter.hasNext())
44          {
45             bIter.next(); // 移動下一個元素
46             bIter.remove(); // 刪除元素
47          }
48       }
49 
50       System.out.println(b);
51 
53 
54       a.removeAll(b);
55 
56       System.out.println(a);//經過AbstractCollection類中的toString方法打印出鏈表a中的全部元素
57    }
58 }

測試程序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 import java.util.*;
 2 public class SetDemo {
 3     public static void main(String[] argv) {
 4         HashSet h = new HashSet(); //也能夠 Set h=new HashSet()
 5         h.add("One");
 6         h.add("Two");
 7         h.add("One"); // 複製
 8         h.add("Three");
 9         Iterator it = h.iterator();
10         while (it.hasNext()) {
11              System.out.println(it.next());
12         }
13     }
14 }

l 在Elipse環境下調試教材365頁程序9-2，結合運行結果理解程序；瞭解HashSet類的用途及經常使用API。

 1 package set;
 2 
 3 import java.util.*;
 4 
 5 /**
 6  * This program uses a set to print all unique words in System.in.
 7  * 
 8  * @version 1.12 2015-06-21
 9  * @author Cay Horstmann
10  */
11 public class SetTest {
12     public static void main(String[] args) {
13         Set<String> words = new HashSet<>(); // 對哈希表進行設置
14         long totalTime = 0;
15 
16         try (Scanner in = new Scanner(System.in)) {
17             while (in.hasNext()) {
18                 String word = in.next();
19                 long callTime = System.currentTimeMillis();
20                 words.add(word);
21                 callTime = System.currentTimeMillis() - callTime;
22                 totalTime += callTime;
23             }
24         }
25 
26         Iterator<String> iter = words.iterator();
27         for (int i = 1; i <= 20 && iter.hasNext(); i++)
28             System.out.println(iter.next());
29         System.out.println(". . .");
30         System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds.");
31     }
32 }

l 在Elipse環境下調試教材367頁-368程序9-三、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);
   }
}

 1 import java.util.*;
 2 
 3 /**
 4  * This program sorts a set of item by comparing their descriptions.
 5  * @version 1.12 2015-06-21
 6  * @author Cay Horstmann
 7  */
 8 public class TreeSetTest
 9 {
10    public static void main(String[] args)
11    {
12       SortedSet<Item> parts = new TreeSet<>();
13       parts.add(new Item("Toaster", 1234));
14       parts.add(new Item("Widget", 4562));
15       parts.add(new Item("Modem", 9912));
16       System.out.println(parts);
17 
18       NavigableSet<Item> sortByDescription = new TreeSet<>(
19             Comparator.comparing(Item::getDescription));//把自定義類對象存入TreeSet進行排序
20 
21       sortByDescription.addAll(parts);
22       System.out.println(sortByDescription);
23    }
24 }

測試程序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);

}

 1 import java.util.*;
 2 public class HashMapDemo //基於哈希表的 Map接口的實現，提供全部可選的映射操做
 3 {
 4    public static void main(String[] argv) {
 5       HashMap h = new HashMap();
 6       // 哈希映射從公司名稱到地址
 7       h.put("Adobe", "Mountain View, CA");
 8       h.put("IBM", "White Plains, NY");
 9       h.put("Sun", "Mountain View, CA");
10       String queryString = "Adobe";
11       String resultString = (String)h.get(queryString);
12       System.out.println("They are located in: " +  resultString);
13   }
14 }

在Elipse環境下調試教材373頁程序9-6，結合程序運行結果理解程序；

l 瞭解HashMap、TreeMap兩個類的用途及經常使用API。

 1 import java.util.*;
 2 
 3 /**
 4  * This program demonstrates the use of a map with key type String and value type Employee.
 5  * @version 1.12 2015-06-21
 6  * @author Cay Horstmann
 7  */
 8 public class MapTest
 9 {
10    public static void main(String[] args)
11    {
12       Map<String, Employee> staff = new HashMap<>();
13       staff.put("144-25-5464", new Employee("Amy Lee"));
14       staff.put("567-24-2546", new Employee("Harry Hacker"));
15       staff.put("157-62-7935", new Employee("Gary Cooper"));
16       staff.put("456-62-5527", new Employee("Francesca Cruz"));
17 
18       // 打印全部條目
19 
20       System.out.println(staff);
21 
22       // 刪除一個條目
23 
24       staff.remove("567-24-2546");
25 
26       // 替換一個條目
27 
28       staff.put("456-62-5527", new Employee("Francesca Miller"));
29 
30       // 查找一個值
31 
32       System.out.println(staff.get("157-62-7935"));
33 
34       // 遍歷全部條目
35 
36       staff.forEach((k, v) -> 
37          System.out.println("key=" + k + ", value=" + v));
38    }
39 }

實驗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。

  1 import java.io.BufferedReader;
  2 import java.io.File;
  3 import java.io.FileInputStream;
  4 import java.io.FileNotFoundException;
  5 import java.io.IOException;
  6 import java.io.InputStreamReader;
  7 import java.util.ArrayList;
  8 import java.util.Arrays;
  9 import java.util.Scanner;
 10 import java.util.Collections;//對集合進行排序、查找、修改等；
 11 
 12 public class Test {
 13     private static ArrayList<Citizen> citizenlist;
 14 
 15     public static void main(String[] args) {
 16         citizenlist = new ArrayList<>();
 17         Scanner scanner = new Scanner(System.in);
 18         File file = new File("E:/java/身份證號.txt");
 19         //異常捕獲
 20         try {
 21             FileInputStream fis = new FileInputStream(file);
 22             BufferedReader in = new BufferedReader(new InputStreamReader(fis));
 23             String temp = null;
 24             while ((temp = in.readLine()) != null) {
 25 
 26                 Scanner linescanner = new Scanner(temp);
 27 
 28                 linescanner.useDelimiter(" ");
 29                 String name = linescanner.next();
 30                 String id = linescanner.next();
 31                 String sex = linescanner.next();
 32                 String age = linescanner.next();
 33                 String birthplace = linescanner.nextLine();
 34                 Citizen citizen = new Citizen();
 35                 citizen.setName(name);
 36                 citizen.setId(id);
 37                 citizen.setSex(sex);
 38                 // 將字符串轉換成10進制數
 39                 int ag = Integer.parseInt(age);
 40                 citizen.setage(ag);
 41                 citizen.setBirthplace(birthplace);
 42                 citizenlist.add(citizen);
 43 
 44             }
 45         } catch (FileNotFoundException e) {
 46             System.out.println("信息文件找不到");
 47             e.printStackTrace();
 48         } catch (IOException e) {
 49             System.out.println("信息文件讀取錯誤");
 50             e.printStackTrace();
 51         }
 52         boolean isTrue = true;
 53         while (isTrue) {
 54 
 55             System.out.println("1.按姓名字典序輸出人員信息");
 56             System.out.println("2.查詢最大年齡的人員信息、查詢最小年齡人員信息");
 57             System.out.println("3.查詢人員中是否查詢人員中是否有你的同鄉");
 58             System.out.println("4.輸入你的年齡，查詢文件中年齡與你最近人的姓名、身份證號、年齡、性別和出生地");
 59             System.out.println("5.退出");
 60             int nextInt = scanner.nextInt();
 61             switch (nextInt) {
 62             case 1:
 63                 Collections.sort(citizenlist);
 64                 System.out.println(citizenlist.toString());
 65                 break;
 66             case 2:
 67                 int max = 0, min = 100;
 68                 int m, k1 = 0, k2 = 0;
 69                 for (int i = 1; i < citizenlist.size(); i++) {
 70                     m = citizenlist.get(i).getage();
 71                     if (m > max) {
 72                         max = m;
 73                         k1 = i;
 74                     }
 75                     if (m < min) {
 76                         min = m;
 77                         k2 = i;
 78                     }
 79                 }
 80                 System.out.println("年齡最大：" + citizenlist.get(k1));
 81                 System.out.println("年齡最小：" + citizenlist.get(k2));
 82                 break;
 83             case 3:
 84                 System.out.println("出生地：");
 85                 String find = scanner.next();
 86                 String place = find.substring(0, 3);
 87                 for (int i = 0; i < citizenlist.size(); i++) {
 88                     if (citizenlist.get(i).getBirthplace().substring(1, 4).equals(place))
 89                         System.out.println("出生地" + citizenlist.get(i));
 90                 }
 91                 break;
 92             case 4:
 93                 System.out.println("年齡：");
 94                 int yourage = scanner.nextInt();
 95                 int near = peer(yourage);
 96                 int j = yourage - citizenlist.get(near).getage();
 97                 System.out.println("" + citizenlist.get(near));
 98                 break;
 99             case 5:
100                 isTrue = false;
101                 System.out.println("程序已退出!");
102                 break;
103             default:
104                 System.out.println("輸入有誤");
105             }
106         }
107     }
108 
109     public static int peer(int age) {
110         int flag = 0;
111         int min = 53, j = 0;
112         for (int i = 0; i < citizenlist.size(); i++) {
113             j = citizenlist.get(i).getage() - age;
114             if (j < 0)
115                 j = -j;
116             if (j < min) {
117                 min = j;
118                 flag = i;
119             }
120         }
121         return flag;
122     }
123 }

 1 public class Citizen implements Comparable<Citizen> {
 2 
 3     private String name;
 4     private String id;
 5     private String sex;
 6     private int age;
 7     private String birthplace;
 8 
 9     public String getName() {
10         return name;
11     }
12 
13     public void setName(String name) {
14         this.name = name;
15     }
16 
17     public String getId() {
18         return id;
19     }
20 
21     public void setId(String id) {
22         this.id = id;
23     }
24 
25     public String getSex() {
26         return sex;
27     }
28 
29     public void setSex(String sex) {
30         this.sex = sex;
31     }
32 
33     public int getage() {
34         return age;
35     }
36 
37     public void setage(int age) {
38         this.age = age;
39     }
40 
41     public String getBirthplace() {
42         return birthplace;
43     }
44 
45     public void setBirthplace(String birthplace) {
46         this.birthplace = birthplace;
47     }
48 
49     public int compareTo(Citizen other) {
50         return this.name.compareTo(other.getName());
51     }
52 
53     public String toString() {
54         return name + "\t" + sex + "\t" + age + "\t" + id + "\t" + birthplace + "\n";
55     }
56 }

實驗結果

實驗十

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

 1 public class Counter {
 2     private int a;
 3     private int b;
 4 
 5     public int add(int a, int b) {
 6         return a + b;
 7     }
 8 
 9     public int reduce(int a, int b) {
10         return a - b;
11     }
12 
13     public int multiplication(int a, int b) {
14         return a * b;
15     }
16 
17     public int division(int a, int b) {
18         if (b != 0)
19             return a / b;
20         else
21             return 0;
22     }
23 
24 }

小夥伴：狄慧

經過結對實驗，對互相存在的問題進行了解決，經過學習交流，對問題的見解有了不同的切入點。結對編程，極大的提升了咱們的編程興趣，和編程效率，是一種很好的編程方式。經過學習交流，對問題的見解有了不同的切入點。

實驗總結：

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兩個類的用途尚且理解不是很到位，在後面的學習中應該進行再理解。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。