1.容器API的類圖結構如下：
JAVA的集合類是一種特別有用的工具類，它可以用於存儲數量不等的多個對象，並可以實現常用數據結構，如棧，隊列等，除此之外，JAVA集合還可用於保存具有映射關系的關聯數組。
JAVA的集合大致上可分為：Set,List和Map三種體系，其中Set代表無序，不可重復的集合；List代表有序，重復的集合，而Map則代表具有遇敵關系的集合。Queue體系集合，代表一種隊列集合實現。
JAVA集合概述：
JAVA提供集合類主要負責保存盛裝其他數據，因此集合類也被稱為容器類。所有集合類都位於java.util包下。
JAVA集合類主要由兩個接口派生而出：Collection和Map，也是根接口。
Map保存的每項數據都是key-value對，也就是由key和value兩個值組成。
下面給個比喻，再給個圖就非常容易理解了。
JAVA的所有集合分成三大類，其中Set 集合類似於一個罐子，把一個對象添加到Set集合時，Set集合無法記住添加這個元素的順序，所以Set里的元素不能重復（否則系統無法准確識別這個元素）
List集合非常像一個數組，它可以記住每次添加元素的順序，只是List長度可變。
Map集合也像一個罐子，只是它里面的每項數據都由兩個值組成。
如果訪問List集合中的元素，可以直接根據元素的索引來訪問，如果需要訪問Map集合中的元素，可以根據每項元素的key來訪問其value，如果希望訪問Set集合中的元素，則只能根據元素本身來訪問（這也是Set集合里元素不允許重復的原因）
對於Set,List和Map三種集合，最常用的實現類，分別是HashSet,ArrayList ,,HashMap 三個實現類。
1.1 Collection接口：
Collection接口——定義了存取一組對象的方法，其子接口Set和List分別定義了存儲方式。
（1）Set中的數據對象沒有順序且不可以重復。
（2）List中的數據對象有順序且可以重復。
Collection接口所定義的方法：
| 方法 |
描述 |
| Boolean add(Object o) |
向集合中添加一個對象的引用 |
| Void clear() |
刪除集合中的所有對象，即不再持有這些對象的引用 |
| Boolean contains(Object o) |
判斷在集合中是否持有特定對象的引用 |
| Boolean isEmpty() |
判斷集合是否為空 |
| Iterator iterator() |
返回一個Iterator對象，可用它來遍歷集合中的元素 |
| Boolean remove(Object o) |
從集合中刪除一個對象的引用 |
| Boolean retainAll(Collection<?> c) |
保留集合中的指定內容 |
| Int size() |
返回集合中元素的數目 |
| Object[] toArray() |
返回一個數組，該數組包含集合中的所有元素 |
| Boolean equals(Object o) |
對象比較 |
| Int hashCode() |
返回hash碼 |
注意：相等的對象應該具有相等的 hash codes。容器類對象在調用remove，contains等方法時需要比較對象是否相等，這回涉及到對象類型的equals方法和hasCode方法；對於自定義的類型，需要重寫equals和hashCode方法以實現自定義的對象相等規則。
Set接口和list接口都繼承了Collection接口，而map接口沒有繼承Collection接口，因此可以對set對象和list對象調用以上方法，但是不能對Map對象調用以上方法。
Collection接口的iterator()和toArray()方法都用於獲取集合中的所有元素，前者返回一個Iterator對象，后者放回一個包含集合中所有元素的數組。
增加Name類的equals和hashCode方法如下：
1 public boolean equals(Object obj){ 2 if(obj instanceof Name){ 3 Name name=(Name)obj; return(firstName.equals(name.firstName)&&lastName.equals(name.lastName));
4 } 5 return super.equals(obj); 6 } 7 public int hashCode(){ 8 return firstName.hashCode(); 9 }
方法應用例子:
1 import java.util.ArrayList; 2 import java.util.Collection; 3 import java.util.HashSet; 4 public class TestCollection{ 5 public static void main(String[] args){ 6 Collection c= new ArrayList(); 7 c.add("孫悟空"); 8 c.add(6); 9 System.out.println("c集合的元素的個數為:"+c.size()); 10 System.out.println("c集合里面是否包含孫悟空字符"+" "+c.contains("孫悟空")); 11 c.add("世界你好"); 12 System.out.println("c集合里面的元素:"+c); 13 Collection books=new HashSet(); //HashSet不允許元素重復。 14 books.add("世界你好"); 15 books.add("你好世界"); 16 System.out.println("c集合里面是否完全包含books:"+c.contains(books)); 17 c.removeAll(books); 18 System.out.println("c集合中的元素:"+c); 19 c.clear(); 20 System.out.println("c集合里面的元素:"+c); 21 books.retainAll(c); 22 System.out.println("books集合的元素:"+books); 23 24 } 25 }
輸出結果：
c集合的元素的個數為:2
c集合里面是否包含孫悟空字符 true
c集合里面的元素:[孫悟空, 6, 世界你好]
c集合里面是否完全包含books:false
c集合中的元素:[孫悟空, 6]
c集合里面的元素:[]
books集合的元素:[]
1.2 Iterator接口:
使用Iterator接口遍歷集合元素，Iterator接口是JAVA集合框架的成員，也被稱為迭代器。
Iterator接口中聲明了如下方法：
boolean hashNext（）：如果迭代的集合元素還沒被遍歷，則返回true
Object next（）：返回集合里下一個元素。
Void remove（）：刪除集合里上一次next方法返回的元素。
1 import java.util.Collection; 2 import java.util.HashSet; 3 import java.util.Iterator; 4 public class TextIterator { 5 public static void main(String[] args){ 6 Collection books=new HashSet(); //無序序列,元素不可重復 7 books.add("世界你好"); 8 books.add("你好世界"); 9 books.add("你好Java"); 10 System.out.println("現在結合的元素:"+books); 11 Iterator it=books.iterator(); //獲取books集合對應的迭代器。 12 while(it.hasNext()){ 13 String book=(String)it.next(); //it.next()方法返回的數據類型是object類型,需要強制類型轉換。 14 System.out.println(book); 15 if(book.equals("你好世界")){ 16 it.remove(); //從集合中刪除上一次next方法返回的元素。 17 } 18 book="測試字符串"; //對book變量賦值,不會改變集合元素本身。 19 } 20 System.out.println(books); 21 22 23 }
輸出結果：
現在結合的元素:[世界你好, 你好Java, 你好世界]
世界你好
你好Java
你好世界
[世界你好, 你好Java]
Iterator僅用於遍歷集合，Iterator本身並不提供盛裝對象的能力，如果需要創建Iterator對象，則必須有一個被迭代的集合。
Iterator必須依附於Collection對象，有一個Iterator對象，則必然有一個懷之關聯的Collection對象。Iterator提供了2個方法來迭代訪問Collection集合里的元素。
結論：當使用Iterator對集合元素進行迭代時，Iterator並不是把集合元素本身傳給了迭代變量，而是把集合元素的值傳給了迭代變量，所以修改迭代變量的值對集合元素本身沒有任何改變。
1.3使用foreach循環遍歷集合元素
我們知道，除了可以使用Iterator類迭代訪問Collection集合里的元素之外，現在還可以使用foreach循環來迭代訪問集合元素會更加便捷。
1 import java.util.Collection; 2 import java.util.HashSet; 3 4 public class TextForeach { 5 public static void main(String[] args){ 6 Collection books=new HashSet(); 7 books.add("世界您好"); 8 books.add("您好世界"); 9 books.add("您好JAVA"); 10 for(Object obj:books){ 11 String book=(String)obj; //此處的book變量也不是集合元素本身 12 System.out.println(book); 13 if(book.equals("您好世界")) { 14 books.remove(book); 15 } 16 17 } 18 19 System.out.println(books); 20 21 }
輸出結果：
現在結合的元素:[世界你好, 你好Java, 你好世界]
世界你好
你好Java
你好世界
[世界你好, 你好Java]
1.4 Set集合的通用知識:
1.4.1HashSet類：
HashSet是Set接口的典型實現，大多數時候使用Set集合時就是使用這個實現類。HashSet按Hash算法一存儲集合中的元素，因此具有很好的存取和查找性能。
特點：
》不能保證元素的排列順序，順序有可能發生變化。
》HashSet來是同步的，如果多個線程同時訪問一個Set集合，如果多個線程同時訪問一個HashSet，如果有2條或者2條以上線程同時修改了HashSet集合，必須通過代碼來保證其同步。
》集合元素值可以是Null
我們可以簡單的認為：HashSet集合判斷兩個元素相等的標准是兩個對象通過equals方法比較相等，並且兩個對象的hashCode()方法返回值也相等。
1 import java.util.*; 2 class A{ //類A的equals方法總是返回true，但沒有重寫其hashCode()方法 3 public boolean equals(Object obj){ 4 return true; 5 } 6 } 7 class B{ //類B的hashCode()方法總是返回l,但沒有重寫equals()方法 8 public int hashCode(){ 9 return 1; 10 } 11 } 12 class C{ //類C的hashCode()方法總是返回2，重寫其equals()方法 13 public int hashCode(){ 14 return 2; 15 } 16 public boolean equals(Object obj){ 17 return true; 18 } 19 } 20 public class TextHashset{ 21 public static void main(String[] args){ 22 HashSet books = new HashSet(); 23 books.add(new A()); 24 books.add(new A()); 25 books.add(new B()); 26 books.add(new B()); 27 books.add(new C()); 28 books.add(new C()); 29 30 } 31 }
我們從編譯結果可以看出，即使2個A對象通過equals比較返回true，但HashSet依然把它們當成2個，即使2個B對象的hashCode()返回相同值（都是1）但，HashSet依然把它們當成2個對象。
簡單的提醒點：
如果需要某個類的對象保存到HashSet集合中，重寫這個類的equals()方法和hashCode()方法時，應該盡量保證兩個對象通過equals比較返回true時，它們的hashCode方法返回值也相等。
HashSet采用每個元素的hashCode作為其索引，從而可以自由增加HashSet的長度，並可以根據元素的hashCode值來訪問該元素。
（我們可以理解為相當於數組里的下標索引)。
因為hashCode()方法很重要，看看重寫hashCode()方法的基本規則。
》當兩個對象通過equals方法比較返回true時，這個兩個對象的hashCode應該相等。
》對象中用作equals比較標准的屬性，都應該用來計算hashCode值。
1 import java.util.Iterator; 2 3 class R{ 4 int count; 5 public R(int count){ 6 this.count=count; 7 } 8 public String toString(){ 9 return "R[count"+count+"]"; 10 } 11 public boolean equals(Object obj){ 12 if(obj instanceof R){ 13 R f=(R)obj; 14 if(f.count==this.count){ 15 return true; 16 } 17 } 18 return false; 19 } 20 public int hashCode(){ 21 return this.count; 22 } 23 } 24 public class TestHashSet2{ 25 public static void main(String[] args){ 26 HashSet hs=new HashSet(); 27 hs.add(new R(5)); 28 hs.add(new R(-3)); 29 hs.add(new R(9)); 30 hs.add(new R(-2)); 31 System.out.println("第1個hs,集合中的元素："+hs+"\n"); //打印HashSet集合，集合元素沒有重復 32 Iterator it=hs.iterator(); 33 R first = (R)it.next(); 34 first.count = -3; //為第一個元素的count實例變量賦值 35 System.out.println("第2個hs,集合中的元素："+hs+"\n"); 36 hs.remove(new R(-3)); //刪除count為-3的R對象 37 System.out.println("第3個hs,集合中的元素："+hs+"\n"); 38 System.out.println("hs是否包含count為-3的R對象？"+hs.contains(new R(-3))); //輸出false 39 System.out.println("hs是否包含count為5的R對象"+hs.contains(new R(5))); //輸出false 40 } 41 }
輸出結果:
第1個hs,集合中的元素：[R[count5], R[count9], R[count-3], R[count-2]]
第2個hs,集合中的元素：[R[count-3], R[count9], R[count-3], R[count-2]]
第3個hs,集合中的元素：[R[count-3], R[count9], R[count-2]]
hs是否包含count為-3的R對象？false
hs是否包含count為5的R對象false
ps:
（1）object類中的hashcode()方法比較的是對象的地址（引用地址），使用new方法創建對象，兩次生成的當然是不同的對象，造成的結果就是兩個對象的hashcode()返回的值不一樣。所以hashset會把new方法創建的兩個它們當作不同的對象對待，
（2）在java的集合中，判斷兩個對象是否相等的規則是：
a)，判斷兩個對象的hashCode是否相等
如果不相等，認為兩個對象也不相等，完畢
如果相等，轉入2)
（這一點只是為了提高存儲效率而要求的，其實理論上沒有也可以，但如果沒有，實際使用時效率會大大降低，所以我們這里將其做為必需的。）
b)，判斷兩個對象用equals運算是否相等
如果不相等，認為兩個對象也不相等
如果相等，認為兩個對象相等（equals()是判斷兩個對象是否相等的關鍵）
LinkedHashSet類:
HashSet還有一個子類LinkedHashSet,它也是根據元素hashCode值來決定元素存儲位置，它是需要維護元素的插入順序，因此性能略低於HashSet的性能，但在迭代訪問Set里的全部元素時將有很好的性能，因為它以鏈表來維護內部順序。
1 import java.util.LinkedHashSet; 2 public class LinkedHashSetTest{ 3 public static void main(String[] args){ 4 LinkedHashSet books = new LinkedHashSet(); 5 books.add("世界您好"); 6 books.add("您好世界"); 7 System.out.println(books); 8 books.remove("世界您好"); //刪除世界您好 9 books.add("世界您好"); //重新添加世界您好 10 System.out.println(books); 11 } 12 }
輸出結果:
[世界您好, 您好世界]
[您好世界, 世界您好]
編譯結果相信大家都理解，因為元素的順序正好與添加順序一致。