1. Java 集合簡介

Java 的初期版本提供了 Dictionary, Vector, Stack, 和 Properties 等類用來儲存和操作物件組。

這些類的功能很有用，但是它們缺少一個核心的、統一的主題（或基類），相互之間缺乏互操作性。比如，使用 Vector 類和使用 Properties 類的方式有很大的不同，兩者的相容性很差。

之後 Java 的版本提供了集合，集合就是一個用來存放物件的容器，比如 ArrayList、HashMap 等。

1) 集合的特點：

(1) 長度可以發生改變；
(2) 只能儲存物件；
(3) 可以儲存多種型別物件；

2) 集合與陣列區別：

陣列 集合
長度 固定 可變
儲存元素 基本型別/引用型別 引用型別
元素型別的一致性 必須一致 可以不一致

2. Java 集合框架

集合框架是 Java 中用來表示集合，和操作集合的所有類庫的統稱。

Java 集合框架特點：

1) 高效能的，基本集合（動態陣列，連結串列，樹，雜湊表）的實現是高效的；
2) 不同型別的集合，以類似的方式工作，具有高度的互操作性；
3) 對一個集合的擴充套件和適應是簡單的；

所有集合類都位於 java.util 包下。Java的集合類主要由兩個介面派生而出：Collection 和 Map，Collection 和 Map 是 Java 集合框架的根介面，這兩個介面又包含了一些子介面或實現類。

Collection 介面繼承了 Iterable 介面，用於實現 Iterator 介面。

集合的關係如下：

Collection 介面
|-- List 介面
| |-- ArrayList 類
| |-- LinkedList 類
| |-- Vector 類
|
|-- Set 介面
| |-- SortedSet 介面
| | |-- TreeSet 類
| |
| |-- HashSet 類
|
|-- Queue 介面

Map 介面
|-- HashMap 類
|-- Hashtable 類
|-- SortedMap 介面
|-- TreeMap 類

3. Collection 介面

Collection 介面是 Java 集合框架的一個基礎介面，Collection 也稱為單列集合，一次可以新增一個元素。

Collection 介面有 3 種子型別集合: List、Set 和 Queue，常用的實現類有 ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue 等。

Collection 的方法:

boolean add(Object obj): 向集合中新增一個元素
boolean addAll(Collection c)：向集合中新增一個集合的元素。

void clear()：刪除集合中的所有元素。
boolean remove(Object obj)：從集合中刪除指定的元素
boolean removeAll(Collection c): 從集合中刪除一個指定的集合元素。

boolean isEmpty()：判斷集合是否為空。
boolean contains(Object obj)：判斷集合中是否存在指定的元素。
boolean containsAll(Collection c)：判斷集合中是否存在指定的一個集合中的元素。

Iterator iterator(): 就是用來獲取集合中每一個元素。

int size(): 獲取集合中的元素個數
boolean retainAll(Collection c): 判斷兩個集合中是否有相同的元素。???
Object[] toArray(): 把集合變成陣列。

4. Map 介面

Map 介面也是 Java 集合框架的一個基礎介面，Map 也被稱為雙列集合，每次可以新增一對元素。雙列集合就是以鍵值對的形式儲存資料，鍵不能重複，鍵具有唯一性。

Map 儲存具有對映關係的資料，因此 Map 集合裡儲存著兩組數，一組值是 Map 裡的 key，另一組是 Map 裡的 value，key 和 value 都可以是任何引用型別的資料。

Map 的方法：

Object put(Object k, Object v): 將指定的值與此對映中的指定鍵關聯（可選操作）。
void putAll(Map m): 從指定對映中將所有對映關係複製到此對映中（可選操作）。

void clear(): 從此對映中移除所有對映關係（可選操作）。
Object remove(Object k): 如果存在一個鍵的對映關係，則將其從此對映中移除（可選操作）。

boolean isEmpty(): 如果此對映未包含鍵-值對映關係，則返回 true。
boolean containsKey(Object k): 如果此對映包含指定鍵的對映關係，則返回 true。
boolean containsValue(Object v): 如果此對映將一個或多個鍵對映到指定值，則返回 true。
boolean equals(Object obj): 比較指定的物件與此對映是否相等。

Object get(Object k): 返回指定鍵所對映的值；如果此對映不包含該鍵的對映關係，則返回 null。
int size(): 返回此對映中的鍵-值對映關係數。

int hashCode(): 返回此對映的雜湊碼值。
Set entrySet(): 返回此對映中包含的對映關係的 Set 檢視。
Set keySet(): 返回此對映中包含的鍵的 Set 檢視。
Collection values(): 返回此對映中包含的值的 Collection 檢視。

5. Iterator（迭代器）

Java 集合框架的集合類(或稱為容器)，容器的種類有很多種，比如 ArrayList、LinkedList、HashSet 等，每種容器都有自己的特點，每種容器都有自己特有的資料結構。

因為容器的內部結構不同，很多時候可能不知道該怎樣去遍歷一個容器中的元素。所以為了使對容器內元素的操作更為簡單，Java引入了迭代器模式！把訪問邏輯從不同型別的集合類中抽取出來，從而避免向外部暴露集合的內部結構。

迭代器模式：就是提供一種方法對一個容器物件中的各個元素進行訪問，而又不暴露該物件容器的內部細節。

Iterator（迭代器）不是一個集合，它是一種用於訪問集合的方法，Iterator 是 Java 迭代器最簡單的實現。

Iterator（迭代器）的基本操作：

(1) next 返回迭代器的下一個元素，並且更新迭代器的狀態;
(2) hasNext() 用於檢測集合中是否還有元素;
(3) remove() 將迭代器返回的元素刪除;

這裡以 ArrayList 為例，操作迭代器：

 1         // 建立 ArrayList 集合
 2         ArrayList<String> testList = new ArrayList<String>();
 3         testList.add("Array List");
 4         testList.add("Tree Set");
 5         testList.add("Hash Map");
 6 
 7         // 獲取迭代器
 8         Iterator<String> it = testList.iterator();
 9 
10         // 遍歷集合
11         while(it.hasNext()) {
12             System.out.println(it.next());
13         }

例項：

 1     import java.util.ArrayList;
 2     import java.util.Iterator;
 3     import java.util.HashMap;
 4 
 5     public class App {
 6         public static void main( String[] args ) {
 7 
 8             // 建立 ArrayList 集合
 9             ArrayList<String> arrayList = new ArrayList<String>();
10             arrayList.add("Array List");
11             arrayList.add("Tree Set");
12             arrayList.add("Hash Map");
13             System.out.println(arrayList);
14 
15             // 用迭代器遍歷集合
16             Iterator<String> it = arrayList.iterator();
17             while (it.hasNext()) {
18                 System.out.println("arrayList(iterator): " + it.next());
19             }
20 
21             // 用 for 迴圈遍歷集合
22             for (String str : arrayList) {
23                 System.out.println("arrayList(for): " + str);
24             }
25 
26             // 刪除元素
27             arrayList.remove(1);
28             System.out.println(arrayList);
29 
30             System.out.println("-------------------------------------------------");
31 
32             // 建立 HashMap 集合
33             HashMap<Integer, String> map = new HashMap<Integer, String>();
34             map.put(1, "Hash Map");
35             map.put(2, "Hash Set");
36             map.put(3, "String Map");
37             map.put(4, "String Set");
38 
39             // 輸出 key 和 value
40             for (Integer i : map.keySet()) {
41                 System.out.println("key: " + i + ", value: " + map.get(i));
42             }
43 
44             // 輸出 value
45             for (String value: map.values()) {
46                 System.out.println(value);
47             }
48 
49         }
50     }

輸出：

[Array List, Tree Set, Hash Map]
arrayList(iterator): Array List
arrayList(iterator): Tree Set
arrayList(iterator): Hash Map
arrayList(for): Array List
arrayList(for): Tree Set
arrayList(for): Hash Map
[Array List, Hash Map]
-------------------------------------------------
key: 1, value: Hash Map
key: 2, value: Hash Set
key: 3, value: String Map
key: 4, value: String Set
Hash Map
Hash Set
String Map
String Set