《面向對象程序設計（java）》第十一週學習總結html
第一部分：理論知識學習部分java
一、通常將數據結構分爲兩大類：線性數據結構和非線性數據結構。線性數據結構：線性表、棧、隊列、串、數組和文件。非線性數據結構：樹和圖。二、線性表按其存儲結構可分爲順序表和鏈表；用順序存儲結構存儲的線性表稱爲順序表；順序表將線性表中的數據元素依次存放在某個存儲區域中。一維數組就是用順序方式存儲的線性表。用鏈式存儲結構存儲的線性表稱爲鏈表。三、棧(Stack)也是一種特殊的線性表，是一種後進先出 (LIFO)的結構。棧是限定僅在表尾進行插入和刪除運算的線性表，表尾稱爲棧頂(top)，表頭稱爲棧底(bottom)。棧的物理存儲能夠用順序存儲結構，也能夠用鏈式存儲結構。四、隊列(Queue)是限定全部的插入只能在表的一端進行 ，而全部的刪除都在表的另外一端進行的線性表。表中容許插入的一端稱爲隊尾(Rear)，容許刪除的一端稱爲隊頭(Front)。隊列的操做是按先進先出(FIFO)的原則進行的。隊列的物理存儲能夠用順序存儲結構，也能夠用鏈式存儲結構。算法
五、散列表又稱爲哈希表。散列表算法的基本思想是：以結點的關鍵字爲自變量，經過必定的函數關係（散列函數）計算出對應的函數值，以這個值做爲該結點存儲在散列表中的地址。當散列表中的元素存放太滿，就必須進行再散列，將產生一個新的散列表，全部元素存放到新的散列表中，原先的散列表將被刪除。在Java語言中，經過負載因子(load factor)來決定什麼時候對散列表進行再散列。負載因子越高 (越接近1.0)，內存的使用效率越高，元素的尋找時間越長。負載因子越低 (越接近0.0)，元素的尋找時間越短，內存浪費越多。HashSet類的缺省負載因子是0.75。
六、JAVA的集合框架實現對各類數據結構的封裝，以下降對數據管理與處理的難度。所謂框架就是一個類庫的集合，框架中包含不少超類，編程者建立這些超類的子類可較方便的設計設計程序所需的類。
七、集合框架：JAVA集合類庫的統一架構。
八、集合類的做用：Java的集合類提供了一些基本數據結構的支持。
九、集合類的使用： Java的集合類包含在java.util包中。
十、集合類的特色一：只容納對象。注意：數組能夠容納基本數據類型數據和對象。若是集合類中想使用基本數據類型，又想利用集合類的靈活性，能夠把基本數據類型數據封裝成該數據類型的包裝器對象，而後放入集合中處理。
特色二：集合類容納的對象都是Object類的實例，一旦把一個對象置入集合類中，它的類信息將丟失，這樣設計的目的是爲了集合類的通用性。由於Object類是全部類的祖先，因此能夠在這些集合中存聽任 何類的對象而不受限制，但在使用集合成員以前必須對它從新造型。
十一、Vector類相似長度可變的數組。Vector中只能存放對象。Vector的元素經過下標進行訪問。 Vector類關鍵屬性：capacity表示集合最多能容納的元素個數。capacityIncrement表示每次增長多少容量。size表示集合當前元素個數。
十二、Stack類是Vector的子類。Stack類描述堆棧數據結構，即LIFO。
1三、Hashtable經過鍵來查找元素。Hashtable用散列碼（hashcode）來肯定鍵。全部對象都有一個散列碼，能夠經過Object類的hashCode()方法得到。
1四、集合框架中的基本接口：Collection：集合層次中的根接口，JDK未提供這個接口的直接實現類。
1五、Set：不能包含重複的元素。對象可能不是按存放的次序存放，也就是說不能像數組同樣按索引的方式進行訪問，SortedSet是一個按照升序排列元素的Set。
List：是一個有序的集合，能夠包含重複的元素。提供了按索引訪問的方式。
Map：包含了key-value對。Map不能包含重複的key。
SortedMap是一個按照升序排列key的Map。
Collection接口：構造類集框架的基礎。
1六、List的明顯特徵是它的元素都有一個肯定的順序。實現它的類有ArrayList和LinkedList。ArrayList中的元素在內存中是順序存儲的。LinkedList中的元素在內存中是以鏈表方式存儲的。
ArrayList：能夠將其看做是可以自動增加容量的數組。利用ArrayList的toArray()返回一個數組。Arrays.asList()返回一個列表。LinkedList是採用雙向循環鏈表實現的。利用LinkedList實現棧(stack)、隊列(queue)、雙向隊列 (double-ended queue )。ArrayList底層採用數組完成，而LinkedList則是以通常的雙向鏈表(double-linked list)完成，其內每一個對象除了數據自己外，還有兩個引用，分別指向前一個元素和後一個元素。若是常常在 List 中進行插入和刪除操做，應該使用LinkedList，不然，使用ArrayList將更加快速。
Set中的元素必須惟一。添加到Set中的對象元素必須定義equals方法，以提供算法來判斷欲添加進來的對象是否與已經存在的某對象相等，從而創建對象的惟一性。實現Set接口的類有HashSet，TreeSet。
1七、TreeSet是一個有序集合，TreeSet中元素將按照升序排列，缺省是按照天然順序進行排列，意味着TreeSet中元素要實現Comparable接口。能夠在構造TreeSet對象時，傳遞實現了 Comparator接口的比較器對象。HashSet是基於Hash算法實現的，其性能一般都優於TreeSet。一般使用HashSet，須要排序的功能時，使用TreeSet。
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。
六、JAVA的集合框架實現對各類數據結構的封裝，以下降對數據管理與處理的難度。所謂框架就是一個類庫的集合，框架中包含不少超類，編程者建立這些超類的子類可較方便的設計設計程序所需的類。
七、集合框架：JAVA集合類庫的統一架構。
八、集合類的做用：Java的集合類提供了一些基本數據結構的支持。
九、集合類的使用： Java的集合類包含在java.util包中。
十、集合類的特色一：只容納對象。注意：數組能夠容納基本數據類型數據和對象。若是集合類中想使用基本數據類型，又想利用集合類的靈活性，能夠把基本數據類型數據封裝成該數據類型的包裝器對象，而後放入集合中處理。
特色二：集合類容納的對象都是Object類的實例，一旦把一個對象置入集合類中，它的類信息將丟失，這樣設計的目的是爲了集合類的通用性。由於Object類是全部類的祖先，因此能夠在這些集合中存聽任 何類的對象而不受限制，但在使用集合成員以前必須對它從新造型。
十一、Vector類相似長度可變的數組。Vector中只能存放對象。Vector的元素經過下標進行訪問。 Vector類關鍵屬性：capacity表示集合最多能容納的元素個數。capacityIncrement表示每次增長多少容量。size表示集合當前元素個數。
十二、Stack類是Vector的子類。Stack類描述堆棧數據結構，即LIFO。
1三、Hashtable經過鍵來查找元素。Hashtable用散列碼（hashcode）來肯定鍵。全部對象都有一個散列碼，能夠經過Object類的hashCode()方法得到。
1四、集合框架中的基本接口：Collection：集合層次中的根接口，JDK未提供這個接口的直接實現類。
1五、Set：不能包含重複的元素。對象可能不是按存放的次序存放，也就是說不能像數組同樣按索引的方式進行訪問，SortedSet是一個按照升序排列元素的Set。
List：是一個有序的集合，能夠包含重複的元素。提供了按索引訪問的方式。
Map：包含了key-value對。Map不能包含重複的key。
SortedMap是一個按照升序排列key的Map。
Collection接口：構造類集框架的基礎。
1六、List的明顯特徵是它的元素都有一個肯定的順序。實現它的類有ArrayList和LinkedList。ArrayList中的元素在內存中是順序存儲的。LinkedList中的元素在內存中是以鏈表方式存儲的。
ArrayList：能夠將其看做是可以自動增加容量的數組。利用ArrayList的toArray()返回一個數組。Arrays.asList()返回一個列表。LinkedList是採用雙向循環鏈表實現的。利用LinkedList實現棧(stack)、隊列(queue)、雙向隊列 (double-ended queue )。ArrayList底層採用數組完成，而LinkedList則是以通常的雙向鏈表(double-linked list)完成，其內每一個對象除了數據自己外，還有兩個引用，分別指向前一個元素和後一個元素。若是常常在 List 中進行插入和刪除操做，應該使用LinkedList，不然，使用ArrayList將更加快速。
Set中的元素必須惟一。添加到Set中的對象元素必須定義equals方法，以提供算法來判斷欲添加進來的對象是否與已經存在的某對象相等，從而創建對象的惟一性。實現Set接口的類有HashSet，TreeSet。
1七、TreeSet是一個有序集合，TreeSet中元素將按照升序排列，缺省是按照天然順序進行排列，意味着TreeSet中元素要實現Comparable接口。能夠在構造TreeSet對象時，傳遞實現了 Comparator接口的比較器對象。HashSet是基於Hash算法實現的，其性能一般都優於TreeSet。一般使用HashSet，須要排序的功能時，使用TreeSet。
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。
第二部分：實驗部分編程
1.實驗名稱：實驗十一 集合數組
2. 實驗目的：數據結構
(1) 掌握Vetor、Stack、Hashtable三個類的用途及經常使用API；架構
(2) 瞭解java集合框架體系組成；框架
(3) 掌握ArrayList、LinkList兩個類的用途及經常使用API。dom
(4) 瞭解HashSet類、TreeSet類的用途及經常使用API。函數
(5)瞭解HashMap、TreeMap兩個類的用途及經常使用API；
(6) 結對編程（Pair programming）練習，體驗程序開發中的兩人合做。
3. 實驗步驟與內容：
實驗1： 導入第9章示例程序，測試程序並進行代碼註釋。
測試程序1：
l 使用JDK命令運行編輯、運行如下三個示例程序，結合運行結果理解程序；
l 掌握Vetor、Stack、Hashtable三個類的用途及經常使用API。
注意：示例程序1出現強制類型轉換異常：
代碼修改以下：
方法1、
1 //示例程序1 2 import java.util.Vector; 3 4 class Cat { 5 private int catNumber; 6 7 Cat(int i) { 8 catNumber = i; 9 } 10 11 void print() { 12 System.out.println("Cat #" + catNumber); 13 } 14 } 15 16 class Dog { 17 private int dogNumber; 18 19 Dog(int i) { 20 dogNumber = i; 21 } 22 23 void print() { 24 System.out.println("Dog #" + dogNumber); 25 } 26 } 27 28 public class CatsAndDogs { 29 public static void main(String[] args) { 30 Vector cats = new Vector(); 31 for (int i = 0; i < 7; i++) 32 cats.addElement(new Cat(i)); 33 cats.addElement(new Cat(7)); 34 for (int i = 0; i < cats.size(); i++) 35 ((Cat) cats.elementAt(i)).print(); 36 } 37 }
運行結果以下：
方法2、
1 //示例程序1 2 import java.util.Vector; 3 4 class Cat { 5 private int catNumber; 6 7 Cat(int i) { 8 catNumber = i; 9 } 10 11 void print() { 12 System.out.println("Cat #" + catNumber); 13 } 14 } 15 16 class Dog { 17 private int dogNumber; 18 19 Dog(int i) { 20 dogNumber = i; 21 } 22 23 void print() { 24 System.out.println("Dog #" + dogNumber); 25 } 26 } 27 28 public class CatsAndDogs { 29 public static void main(String[] args) { 30 Vector cats = new Vector(); 31 32 for (int i = 0; i < 7; i++) 33 cats.addElement(new Cat(i)); 34 cats.addElement(new Dog(7)); 35 36 for(int i = 0;i < cats.size(); i++) { 37 if(cats.elementAt(i) instanceof Cat) { 38 39 ((Cat) cats.elementAt(i)).print(); 40 41 }else { 42 43 ((Dog) cats.elementAt(i)).print(); 44 45 } 46 } 47 48 /*for (int i = 0; i < cats.size(); i++) 49 ((Cat) cats.elementAt(i)).print(); 50 */ 51 } 52 }
運行結果以下：
1 //示例程序2 2 import java.util.*; 3 4 public class Stacks { 5 static String[] months = { "1", "2", "3", "4" }; 6 7 public static void main(String[] args) { 8 Stack stk = new Stack(); 9 for (int i = 0; i < months.length; i++) 10 stk.push(months[i]); 11 System.out.println(stk); 12 System.out.println("element 2=" + stk.elementAt(2)); 13 while (!stk.empty()) 14 System.out.println(stk.pop()); 15 } 16 }
運行結果以下：
1 //示例程序3 2 import java.util.*; 3 4 class Counter { 5 int i = 1; 6 7 public String toString() { 8 return Integer.toString(i); 9 } 10 } 11 12 public class Statistics { 13 public static void main(String[] args) { 14 Hashtable ht = new Hashtable(); 15 for (int i = 0; i < 10000; i++) { 16 Integer r = new Integer((int) (Math.random() * 20));//隨機生成一個【0，20）之內的隨機數 17 if (ht.containsKey(r)) 18 ((Counter) ht.get(r)).i++; 19 else 20 ht.put(r, new Counter()); 21 } 22 System.out.println(ht); 23 } 24 }
運行結果以下：
測試程序2：
l 使用JDK命令編輯運行ArrayListDemo和LinkedListDemo兩個程序，結合程序運行結果理解程序；
1 import java.util.*; 2 3 4 5 public class ArrayListDemo { 6 7 public static void main(String[] argv) { 8 9 ArrayList al = new ArrayList(); 10 11 // Add lots of elements to the ArrayList... 12 13 al.add(new Integer(11)); 14 15 al.add(new Integer(12)); 16 17 al.add(new Integer(13)); 18 19 al.add(new String("hello")); 20 21 // First print them out using a for loop. 22 23 System.out.println("Retrieving by index:"); 24 25 for (int i = 0; i < al.size(); i++) { 26 27 System.out.println("Element " + i + " = " + al.get(i)); 28 29 } 30 31 } 32 33 }
運行結果以下：
1 import java.util.*; 2 3 public class LinkedListDemo { 4 5 public static void main(String[] argv) { 6 7 LinkedList l = new LinkedList(); 8 9 l.add(new Object()); 10 11 l.add("Hello"); 12 13 l.add("zhangsan"); 14 15 ListIterator li = l.listIterator(0); 16 17 while (li.hasNext()) 18 19 System.out.println(li.next()); 20 21 if (l.indexOf("Hello") < 0) 22 23 System.err.println("Lookup does not work"); 24 25 else 26 27 System.err.println("Lookup works"); 28 29 } 30 31 }
運行結果以下：
l 在Elipse環境下編輯運行調試教材360頁程序9-1，結合程序運行結果理解程序；
l 掌握ArrayList、LinkList兩個類的用途及經常使用API。
1 package linkedList; 2 3 import java.util.*; 4 5 /** 6 * This program demonstrates operations on linked lists. 7 * @version 1.11 2012-01-26 8 * @author Cay Horstmann 9 */ 10 public class LinkedListTest 11 { 12 public static void main(String[] args) 13 { 14 List<String> a = new LinkedList<>(); 15 a.add("Amy"); 16 a.add("Carl"); 17 a.add("Erica"); 18 19 List<String> b = new LinkedList<>(); 20 b.add("Bob"); 21 b.add("Doug"); 22 b.add("Frances"); 23 b.add("Gloria"); 24 25 // merge the words from b into a 26 27 ListIterator<String> aIter = a.listIterator(); 28 Iterator<String> bIter = b.iterator(); 29 30 while (bIter.hasNext()) 31 { 32 if (aIter.hasNext()) aIter.next(); 33 aIter.add(bIter.next()); 34 } 35 36 System.out.println(a); 37 38 // remove every second word from b 39 40 bIter = b.iterator(); 41 while (bIter.hasNext()) 42 { 43 bIter.next(); // skip one element 44 if (bIter.hasNext()) 45 { 46 bIter.next(); // skip next element 47 bIter.remove(); // remove that element 48 } 49 } 50 51 System.out.println(b); 52 53 // bulk operation: remove all words in b from a 54 55 a.removeAll(b); 56 57 System.out.println(a); 58 } 59 }
運行結果以下：
測試程序3：
l 運行SetDemo程序，結合運行結果理解程序；
1 package linkedList; 2 import java.util.*; 3 4 public class SetDemo { 5 6 public static void main(String[] argv) { 7 8 HashSet h = new HashSet(); //也能夠 Set h=new HashSet() 9 10 h.add("One"); 11 12 h.add("Two"); 13 14 h.add("One"); // DUPLICATE 15 16 h.add("Three"); 17 18 Iterator it = h.iterator(); 19 20 while (it.hasNext()) { 21 22 System.out.println(it.next()); 23 24 } 25 26 } 27 28 }
運行結果以下：
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 * @version 1.12 2015-06-21 8 * @author Cay Horstmann 9 */ 10 public class SetTest 11 { 12 public static void main(String[] args) 13 { 14 Set<String> words = new HashSet<>(); // HashSet implements Set 15 long totalTime = 0; 16 17 try (Scanner in = new Scanner(System.in)) 18 { 19 while (in.hasNext()) 20 { 21 String word = in.next(); 22 long callTime = System.currentTimeMillis(); 23 words.add(word); 24 callTime = System.currentTimeMillis() - callTime; 25 totalTime += callTime; 26 } 27 } 28 29 Iterator<String> iter = words.iterator(); 30 for (int i = 1; i <= 20 && iter.hasNext(); i++) 31 System.out.println(iter.next()); 32 System.out.println(". . ."); 33 System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds."); 34 } 35 }
運行結果以下：
l 在Elipse環境下調試教材367頁-368程序9-三、9-4，結合程序運行結果理解程序；瞭解TreeSet類的用途及經常使用API。
1 package treeSet; 2 3 import java.util.*; 4 5 /** 6 * This program sorts a set of item by comparing their descriptions. 7 * @version 1.12 2015-06-21 8 * @author Cay Horstmann 9 */ 10 public class TreeSetTest 11 { 12 public static void main(String[] args) 13 { 14 SortedSet<Item> parts = new TreeSet<>(); 15 parts.add(new Item("Toaster", 1234)); 16 parts.add(new Item("Widget", 4562)); 17 parts.add(new Item("Modem", 9912)); 18 System.out.println(parts); 19 20 NavigableSet<Item> sortByDescription = new TreeSet<>( 21 Comparator.comparing(Item::getDescription)); 22 23 sortByDescription.addAll(parts); 24 System.out.println(sortByDescription); 25 } 26 }
運行結果以下：
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); } }
運行結果以下：
測試程序4：
l 使用JDK命令運行HashMapDemo程序，結合程序運行結果理解程序；
1 import java.util.*; 2 3 public class HashMapDemo { 4 5 public static void main(String[] argv) { 6 7 HashMap h = new HashMap(); 8 9 // The hash maps from company name to address. 10 11 h.put("Adobe", "Mountain View, CA"); 12 13 h.put("IBM", "White Plains, NY"); 14 15 h.put("Sun", "Mountain View, CA"); 16 17 String queryString = "Adobe"; 18 19 String resultString = (String)h.get(queryString); 20 21 System.out.println("They are located in: " + resultString); 22 23 } 24 25 }
運行結果以下：
l 在Elipse環境下調試教材373頁程序9-6，結合程序運行結果理解程序；
l 瞭解HashMap、TreeMap兩個類的用途及經常使用API。
1 package map; 2 3 /** 4 * A minimalist employee class for testing purposes. 5 */ 6 public class Employee 7 { 8 private String name; 9 private double salary; 10 11 /** 12 * Constructs an employee with $0 salary. 13 * @param n the employee name 14 */ 15 public Employee(String name) 16 { 17 this.name = name; 18 salary = 0; 19 } 20 21 public String toString() 22 { 23 return "[name=" + name + ", salary=" + salary + "]"; 24 } 25 }
1 package map; 2 3 import java.util.*; 4 5 /** 6 * This program demonstrates the use of a map with key type String and value type Employee. 7 * @version 1.12 2015-06-21 8 * @author Cay Horstmann 9 */ 10 public class MapTest 11 { 12 public static void main(String[] args) 13 { 14 Map<String, Employee> staff = new HashMap<>(); 15 staff.put("144-25-5464", new Employee("Amy Lee")); 16 staff.put("567-24-2546", new Employee("Harry Hacker")); 17 staff.put("157-62-7935", new Employee("Gary Cooper")); 18 staff.put("456-62-5527", new Employee("Francesca Cruz")); 19 20 // print all entries 21 22 System.out.println(staff); 23 24 // remove an entry 25 26 staff.remove("567-24-2546"); 27 28 // replace an entry 29 30 staff.put("456-62-5527", new Employee("Francesca Miller")); 31 32 // look up a value 33 34 System.out.println(staff.get("157-62-7935")); 35 36 // iterate through all entries 37 38 staff.forEach((k, v) -> 39 System.out.println("key=" + k + ", value=" + v)); 40 } 41 }
運行結果以下：
實驗2：結對編程練習：
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，結合使用體驗對所運行程序提出完善建議；
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.Collections; 10 import java.util.Scanner; 11 12 public class Main{ 13 private static ArrayList<Person> Personlist; 14 public static void main(String[] args) { 15 Personlist = new ArrayList<>(); 16 Scanner scanner = new Scanner(System.in); 17 File file = new File("D:\\身份證號.txt"); 18 try { 19 FileInputStream fis = new FileInputStream(file); 20 BufferedReader in = new BufferedReader(new InputStreamReader(fis)); 21 String temp = null; 22 while ((temp = in.readLine()) != null) { 23 24 Scanner linescanner = new Scanner(temp); 25 26 linescanner.useDelimiter(" "); 27 String name = linescanner.next(); 28 String ID = linescanner.next(); 29 String sex = linescanner.next(); 30 String age = linescanner.next(); 31 String place =linescanner.nextLine(); 32 Person Person = new Person(); 33 Person.setname(name); 34 Person.setID(ID); 35 Person.setsex(sex); 36 int a = Integer.parseInt(age); 37 Person.setage(a); 38 Person.setbirthplace(place); 39 Personlist.add(Person); 40 41 } 42 } catch (FileNotFoundException e) { 43 System.out.println("查找不到信息"); 44 e.printStackTrace(); 45 } catch (IOException e) { 46 System.out.println("信息讀取有誤"); 47 e.printStackTrace(); 48 } 49 boolean isTrue = true; 50 while (isTrue) { 51 System.out.println("————————————————————————————————————————"); 52 System.out.println("1:按姓名字典序輸出人員信息"); 53 System.out.println("2:查詢最大年齡與最小年齡人員信息"); 54 System.out.println("3：按省份找同鄉"); 55 System.out.println("4:輸入你的年齡,查詢年齡與你最近人的信息"); 56 System.out.println("5：exit"); 57 int nextInt = scanner.nextInt(); 58 switch (nextInt) { 59 case 1: 60 Collections.sort(Personlist); 61 System.out.println(Personlist.toString()); 62 break; 63 case 2: 64 65 int max=0,min=100;int j,k1 = 0,k2=0; 66 for(int i=1;i<Personlist.size();i++) 67 { 68 j=Personlist.get(i).getage(); 69 if(j>max) 70 { 71 max=j; 72 k1=i; 73 } 74 if(j<min) 75 { 76 min=j; 77 k2=i; 78 } 79 80 } 81 System.out.println("年齡最大："+Personlist.get(k1)); 82 System.out.println("年齡最小："+Personlist.get(k2)); 83 break; 84 case 3: 85 System.out.println("place?"); 86 String find = scanner.next(); 87 String place=find.substring(0,3); 88 String place2=find.substring(0,3); 89 for (int i = 0; i <Personlist.size(); i++) 90 { 91 if(Personlist.get(i).getbirthplace().substring(1,4).equals(place)) 92 System.out.println("maybe is "+Personlist.get(i)); 93 94 } 95 96 break; 97 case 4: 98 System.out.println("年齡："); 99 int yourage = scanner.nextInt(); 100 int near=agenear(yourage); 101 int d_value=yourage-Personlist.get(near).getage(); 102 System.out.println(""+Personlist.get(near)); 103 /* for (int i = 0; i < Personlist.size(); i++) 104 { 105 int p=Personlist.get(i).getage()-yourage; 106 if(p<0) p=-p; 107 if(p==d_value) System.out.println(Personlist.get(i)); 108 } */ 109 break; 110 case 5: 111 isTrue = false; 112 System.out.println("退出程序!"); 113 break; 114 default: 115 System.out.println("輸入有誤"); 116 } 117 } 118 } 119 public static int agenear(int age) { 120 121 int j=0,min=53,d_value=0,k=0; 122 for (int i = 0; i < Personlist.size(); i++) 123 { 124 d_value=Personlist.get(i).getage()-age; 125 if(d_value<0) d_value=-d_value; 126 if (d_value<min) 127 { 128 min=d_value; 129 k=i; 130 } 131 132 } return k; 133 134 } 135 136 137 }
1 public class Person implements Comparable<Person> { 2 private String name; 3 private String ID; 4 private int age; 5 private String sex; 6 private String birthplace; 7 8 public String getname() { 9 return name; 10 } 11 public void setname(String name) { 12 this.name = name; 13 } 14 public String getID() { 15 return ID; 16 } 17 public void setID(String ID) { 18 this.ID= ID; 19 } 20 public int getage() { 21 22 return age; 23 } 24 public void setage(int age) { 25 // int a = Integer.parseInt(age); 26 this.age= age; 27 } 28 public String getsex() { 29 return sex; 30 } 31 public void setsex(String sex) { 32 this.sex= sex; 33 } 34 public String getbirthplace() { 35 return birthplace; 36 } 37 public void setbirthplace(String birthplace) { 38 this.birthplace= birthplace; 39 } 40 41 public int compareTo(Person o) { 42 return this.name.compareTo(o.getname()); 43 44 } 45 46 public String toString() { 47 return name+"\t"+sex+"\t"+age+"\t"+ID+"\t"+birthplace+"\n"; 48 49 } 50 51 52 53 }
l 各自運行合做夥伴實驗十編程練習2，結合使用體驗對所運行程序提出完善建議；
1 import java.io.FileNotFoundException; 2 import java.io.PrintWriter; 3 import java.util.Scanner; 4 5 /* 6 * 該程序用來隨機生成0到100之內的加減乘除題 7 */ 8 public class Demo { 9 public static void main(String[] args) { 10 // 用戶的答案要從鍵盤輸入，所以須要一個鍵盤輸入流 11 Scanner in = new Scanner(System.in); 12 Counter counter=new Counter(); 13 PrintWriter out = null; 14 try { 15 out = new PrintWriter("text.txt"); 16 } catch (FileNotFoundException e) { 17 // TODO Auto-generated catch block 18 e.printStackTrace(); 19 } 20 // 定義一個變量用來統計得分 21 int sum = 0; 22 int k=0; 23 // 經過循環生成10道題 24 for (int i = 0; i < 10; i++) { 25 26 // 隨機生成兩個100之內的隨機數做加減乘除 27 int a = (int) Math.round(Math.random() * 100); 28 int b = (int) Math.round(Math.random() * 100); 29 int d = (int) Math.round(Math.random() * 3); 30 31 switch (d){ 32 33 case 0: 34 if(a%b == 0) { 35 System.out.println(a + "/" + b + "="); 36 break; 37 } 38 //int c = in.nextInt(); 39 //out.println(a + "/" + b + "="+c); 40 case 1: 41 System.out.println(a + "*" + b + "="); 42 //int c1 = in.nextInt(); 43 //out.println(a + "*" + b + "="+c1); 44 break; 45 case 2: 46 System.out.println(a + "+" + b + "="); 47 //int c2 = in.nextInt(); 48 //out.println(a + "+" + b + "="+c2); 49 break; 50 case 3: 51 if(a>b) { 52 System.out.println(a + "-" + b + "="); 53 break; 54 } 55 //int c3 = in.nextInt(); 56 //out.println(a + "-" + b + "="+c3); 57 58 } 59 60 // 定義一個整數用來接收用戶輸入的答案 61 double c = in.nextDouble(); 62 63 // 判斷用戶輸入的答案是否正確，正確給10分，錯誤不給分 64 if (c == a / b | c == a * b | c == a + b | c == a - b) { 65 sum += 10; 66 System.out.println("恭喜答案正確"); 67 } 68 else { 69 System.out.println("抱歉，答案錯誤"); 70 71 } 72 out.println(a + "/" + b + "="+c ); 73 out.println(a + "*" + b + "="+c); 74 out.println(a + "+" + b + "="+c); 75 out.println(a + "-" + b + "="+c); 76 77 } 78 //輸出用戶的成績 79 System.out.println("你的得分爲"+sum); 80 81 out.println("成績:"+sum); 82 out.close(); 83 } 84 }
1 public class Counter { 2 private int a; 3 private int b; 4 public int add(int a,int b) 5 { 6 return a+b; 7 } 8 public int reduce(int a,int b) 9 { 10 return a-b; 11 } 12 public int multiplication(int a,int b) 13 { 14 return a*b; 15 } 16 public int division(int a,int b) 17 { 18 if(b!=0) 19 return a/b; 20 else return 0; 21 } 22 23 }
l 採用結對編程方式，與學習夥伴合做完成實驗九編程練習1；
l 採用結對編程方式，與學習夥伴合做完成實驗十編程練習2。
1) 程序互測概述、心得；
結對編程中在測試小夥伴兒的代碼時發現了一些好的語句在我代碼中沒有運用到的，以及一些好的設計本身以前沒有想到的，不少地方都值得我學習和借鑑。
2) 結對編程代碼；
實驗九編程練習1
1 package ID; 2 3 public class Person implements Comparable<Person> { 4 private String name; 5 private String ID; 6 private int age; 7 private String sex; 8 private String birthplace; 9 10 public String getname() { 11 return name; 12 } 13 14 public void setname(String name) { 15 this.name = name; 16 } 17 18 public String getID() { 19 return ID; 20 } 21 22 public void setID(String ID) { 23 this.ID = ID; 24 } 25 26 public int getage() { 27 28 return age; 29 } 30 31 public void setage(int age) { 32 33 this.age = age; 34 } 35 36 public String getsex() { 37 return sex; 38 } 39 40 public void setsex(String sex) { 41 this.sex = sex; 42 } 43 44 public String getbirthplace() { 45 return birthplace; 46 } 47 48 public void setbirthplace(String birthplace) { 49 this.birthplace = birthplace; 50 } 51 52 public int compareTo(Person o) { 53 return this.name.compareTo(o.getname()); 54 } 55 56 public String toString() { 57 return name + "\t" + sex + "\t" + age + "\t" + ID + "\t" + birthplace + "\n"; 58 } 59 }
1 package ID; 2 3 import java.io.BufferedReader; 4 import java.io.File; 5 import java.io.FileInputStream; 6 import java.io.FileNotFoundException; 7 import java.io.IOException; 8 import java.io.InputStreamReader; 9 import java.util.ArrayList; 10 import java.util.Arrays; 11 import java.util.Collections; 12 import java.util.Scanner; 13 14 public class Main { 15 private static ArrayList<Person> Personlist; 16 17 public static void main(String[] args) { 18 Personlist = new ArrayList<>(); 19 Scanner scanner = new Scanner(System.in); 20 File file = new File("身份證號.txt"); 21 try { 22 FileInputStream fis = new FileInputStream(file); 23 BufferedReader in = new BufferedReader(new InputStreamReader(fis)); 24 String temp = null; 25 while ((temp = in.readLine()) != null) { 26 27 Scanner linescanner = new Scanner(temp); 28 29 linescanner.useDelimiter(" "); 30 String name = linescanner.next(); 31 String ID = linescanner.next(); 32 String sex = linescanner.next(); 33 String age = linescanner.next(); 34 String place = linescanner.nextLine(); 35 Person Person = new Person(); 36 Person.setname(name); 37 Person.setID(ID); 38 Person.setsex(sex); 39 int a = Integer.parseInt(age); 40 Person.setage(a); 41 Person.setbirthplace(place); 42 Personlist.add(Person); 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 System.out.println("1:按姓名字典序輸出人員信息"); 55 System.out.println("2:查詢最大年齡與最小年齡人員信息"); 56 System.out.println("3：按省份找同鄉"); 57 System.out.println("4:輸入你的年齡,查詢年齡與你最近人的信息"); 58 System.out.println("5：退出"); 59 int nextInt = scanner.nextInt(); 60 switch (nextInt) { 61 case 1: 62 Collections.sort(Personlist); 63 System.out.println(Personlist.toString()); 64 break; 65 case 2: 66 int max = 0, min = 100; 67 int j, k1 = 0, k2 = 0; 68 for (int i = 1; i < Personlist.size(); i++) { 69 j = Personlist.get(i).getage(); 70 if (j > max) { 71 max = j; 72 k1 = i; 73 } 74 if (j < min) { 75 min = j; 76 k2 = i; 77 } 78 79 } 80 System.out.println("年齡最大：" + Personlist.get(k1)); 81 System.out.println("年齡最小：" + Personlist.get(k2)); 82 break; 83 case 3: 84 System.out.println("省份?"); 85 String find = scanner.next(); 86 String place = find.substring(0, 3); 87 String place2 = find.substring(0, 3); 88 for (int i = 0; i < Personlist.size(); i++) { 89 if (Personlist.get(i).getbirthplace().substring(1, 4).equals(place)) 90 System.out.println("同鄉 " + Personlist.get(i)); 91 92 } 93 94 break; 95 case 4: 96 System.out.println("年齡："); 97 int yourage = scanner.nextInt(); 98 int near = agenear(yourage); 99 int d_value = yourage - Personlist.get(near).getage(); 100 System.out.println("" + Personlist.get(near)); 101 102 break; 103 case 5: 104 isTrue = false; 105 System.out.println("歡迎使用!"); 106 break; 107 default: 108 System.out.println("輸入有誤"); 109 } 110 } 111 } 112 113 public static int agenear(int age) { 114 115 int j = 0, min = 53, d_value = 0, k = 0; 116 for (int i = 0; i < Personlist.size(); i++) { 117 d_value = Personlist.get(i).getage() - age; 118 if (d_value < 0) 119 d_value = -d_value; 120 if (d_value < min) { 121 min = d_value; 122 k = i; 123 } 124 } 125 return k; 126 } 127 }
實驗十編程練習2
1 import java.io.*; 2 import java.io.PrintWriter; 3 import java.util.Scanner; 4 5 public class Main { 6 public static void main(String[] args) { 7 8 Scanner in = new Scanner(System.in); 9 10 PrintWriter output = null; 11 try { 12 output = new PrintWriter("text.txt"); 13 } catch (FileNotFoundException e) { 14 // TODO Auto-generated catch block 15 e.printStackTrace(); 16 } 17 int sum = 0; 18 for (int i = 1; i <= 10; i++) { 19 int a = (int) Math.round(Math.random() * 100); 20 int b = (int) Math.round(Math.random() * 100); 21 int m = (int) Math.round(Math.random() * 4); 22 switch (m) { 23 case 1: 24 while (b == 0) { 25 b = (int) Math.round(Math.random() * 100); 26 } 27 while (a % b != 0) { 28 a = (int) Math.round(Math.random() * 100); 29 } 30 System.out.println(i + ": " + a + "/" + b + "="); 31 int c1 = in.nextInt(); 32 output.println(a + "/" + b + "=" + c1); 33 if (c1 == a / b) { 34 System.out.println("恭喜答案正確"); 35 sum += 10; 36 } else { 37 System.out.println("抱歉，答案錯誤"); 38 } 39 40 break; 41 42 case 2: 43 System.out.println(i + ": " + a + "*" + b + "="); 44 int c2 = in.nextInt(); 45 output.println(a + "*" + b + "=" + c2); 46 if (c2 == a * b) { 47 System.out.println("恭喜答案正確"); 48 sum += 10; 49 } else { 50 System.out.println("抱歉，答案錯誤"); 51 } 52 break; 53 case 3: 54 System.out.println(i + ": " + a + "+" + b + "="); 55 int c3 = in.nextInt(); 56 output.println(a + "+" + b + "=" + c3); 57 if (c3 == a + b) { 58 System.out.println("恭喜答案正確"); 59 sum += 10; 60 } else { 61 System.out.println("抱歉，答案錯誤"); 62 } 63 64 break; 65 case 4: 66 while (a < b) { 67 a = (int) Math.round(Math.random() * 100); 68 } 69 System.out.println(i + ": " + a + "-" + b + "="); 70 int c4 = in.nextInt(); 71 output.println(a + "-" + b + "=" + c4); 72 if (c4 == a - b) { 73 System.out.println("恭喜答案正確"); 74 sum += 10; 75 } else { 76 System.out.println("抱歉，答案錯誤"); 77 } 78 break; 79 80 } 81 82 } 83 System.out.println("成績" + sum); 84 output.println("成績" + sum); 85 output.close(); 86 } 87 }
1 public class math<T> { 2 private T a; 3 private T 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 && a % b == 0) 19 return a / b; 20 else 21 return 0; 22 } 23 }
3) 結對程序運行功能界面截圖；
4) 結對過程描述。
咱們分別運行了對方的程序，得出實驗運行結果，互相閱讀學習了對方代碼中好的語句、想法。並將不懂的地方向對方提出疑問，並獲得解答。學到了不少，受益不淺。
4. 實驗總結：
經過本次實驗我掌握了Vetor、Stack、Hashtable三個類的用途及經常使用的API；瞭解了java集合框架體系的組成；掌握了ArrayList、LinkList兩個類的用途及經常使用的API；瞭解了HashSet類、TreeSet類的用途及經常使用的API；還了解了HashMap、TreeMap兩個類的用途及經常使用的API。
經過結對編程練習，我體驗到了程序開發中與小夥伴合做的樂趣，也懂得了合做學習的重要性，受益不淺。