一、Java 集合框架體系

Java 集合可分為 Collection 和 Map 兩大體系：

• Collection 接口：用于存儲一個一個的數據，也稱單列數據集合。
  • List 子接口：用來存儲有序的、可以重復的數據（主要用來替換數組，"動態"數組）
    實現類:ArrayList(主要實現類)、LinkedList、Vector
  • Set 子接口：用來存儲無序的、不可重復的數據（類似于高中講的"集合"）
    實現類:HashSet(主要實現類)、LinkedHashSet、TreeSet
• Map 接口：用于存儲具有映射關系“key-value 對”的集合，即一對一對的數據，也稱雙列數據集合。(類似于高中的函數、映射。(x1,y1) —> y = f(x) )
  • 實現類:HashMap(主要實現類)、LinkedHashMap、TreeMap、Hashtable、Properties

---

Collection接口的繼承樹:

---

Map接口的繼承樹:

---

二、Collection接口和方法

JDK 不提供此接口的任何直接實現，而是提供更具體的子接口（如：Set 和 List）去實現。

Collection 接口是 List 和 Set 接口的父接口，該接口里定義的方法既可用于操作 Set 集合，也可用于操作 List 集合。

• Collection接口方法:
  • 添加:
    • add(E obj)：添加元素對象到當前集合中
    • addAll(Collection other)：添加other集合的所有元素到當前集合中，即 this = this ∪ other
  • 
  • 判斷:
    • int size()：獲取當前集合中實際存儲的元素個數
    • boolean isEmpty()：判斷當前集合是否為空集合
    • boolean contains(Object obj)：判斷當前集合中是否存在與 obj 對象equals返回true的元素
    • boolean containsAll(Collection coll)：判斷 coll 集合中的元素是否在當前集合中都存在。即 coll 集合是否是當前集合的“子集”
    • boolean equals(Object obj)：判斷當前集合與 obj 是否相等
  • 刪除:
    • void clear()：清空集合元素
    • boolean remove(Object obj) ：從當前集合中刪除第一個找到的與 obj 對象 equals 返回 true 的元素。
    • boolean removeAll(Collection coll)：從當前集合中刪除所有與 coll 集合中相同的元素。即 this = this - this ∩ coll
    • boolean retainAll(Collection coll)：從當前集合中刪除兩個集合中不同的元素，使得當前集合僅保留與 coll 集合中的元素相同的元素，即當前集合中僅保留兩個集合的交集，即 this = this ∩ coll
  • 其他:
    • Object[] toArray()：返回包含當前集合中所有元素的數組
    • hashCode()：獲取集合對象的哈希值
    • iterator()：返回迭代器對象，用于集合遍歷

1. List接口

List 集合類中元素有序、且可重復，集合中的每個元素都有其對應的順序索引。

List集合可以理解為一個可擴展的數組。

List 集合存儲數據，就像銀行門口客服，給每一個來辦理業務的客戶分配序號：第一個來的是“張三”，客服給他分配的是 0；第二個來的是“李四”，客服給他分配的 1；以此類推，最后一個序號應該是“總人數-1”。

• JDK API 中 List 接口的實現類常用的有：ArrayList、LinkedList 和 Vector。

以下是一些List接口操作集合元素的方法:

• 插入元素:
  • void add(int index, Object ele):在 index 位置插入 ele 元素
  • boolean addAll(int index, Collection eles):從 index 位置將 eles 中的所有元素添加進來
• 獲取元素:
  • Object get(int index):獲取指定 index 位置的元素
  • List subList(int fromIndex, int toIndex):返回從 fromIndex 到 toIndex 位置的子集合
• 獲取元素索引:
  • int indexOf(Object obj):返回 obj 在集合中首次出現的位置
  • int lastIndexOf(Object obj):返回 obj 在當前集合中末次出現的位置
• 刪除和替換元素:
  • Object remove(int index):移除指定 index 位置的元素，并返回此元素
  • Object set(int index, Object ele):設置指定 index 位置的元素為ele

package com.example.list;
import java.util.ArrayList;
import java.util.List;
public class TestListMethod {public static void main(String[] args) {// 創建 List 集合對象List<String> list = new ArrayList<String>();// 往 尾部添加 指定元素list.add("圖圖");list.add("小美");list.add("不高興");System.out.println(list); // ["圖圖","小美","不高興"]// add(int index,String s) 往指定位置添加list.add(1,"沒頭腦"); // ["圖圖","沒頭腦","小美","不高興"]System.out.println(list);// String remove(int index) 刪除指定位置元素 返回被刪除元素System.out.println("刪除索引位置為 2 的元素");System.out.println(list.remove(2));System.out.println(list); // ["圖圖","沒頭腦","不高興"]// String set(int index,String s)// 在指定位置 進行 元素替代（改）list.set(0, "三毛");System.out.println(list);// String get(int index) 獲取指定位置元素// 跟 size() 方法一起用 來 遍歷的for(int i = 0;i<list.size();i++){System.out.println(list.get(i));}//還可以使用增強 forfor (String string : list) {System.out.println(string);}}
}

List 接口主要實現類：ArrayList

• ArrayList 是 List 接口的主要實現類
• 本質上，ArrayList 是對象引用的一個”變長”數組
• Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 實例，也不是 Vector 實例。Arrays.asList(…) 返回值是一個固定長度的 List 集合
  

List 的實現類之二：LinkedList

• 對于頻繁的插入或刪除元素的操作，建議使用 LinkedList 類，效率較高。這是由底層采用鏈表（雙向鏈表）結構存儲數據決定的。
• 特有方法:
  • void addFirst(Object obj) 在鏈表表頭添加元素
  • void addLast(Object obj) 在鏈表末尾添加元素
  • Object getFirst() 獲取鏈表第一個元素
  • Object getLast() 獲取鏈表最后一個元素
  • Object removeFirst() 刪除鏈表第一個元素
  • Object removeLast() 刪除鏈表最后一個元素

---

ArraryList和LinkedList的優缺點:

ArrayList 的優缺點：
優點：

1. 隨機訪問快速： ArrayList基于數組實現，可以通過索引進行快速隨機訪問元素。
2. 適合讀取操作： 適合對列表進行頻繁的讀取操作，因為它可以快速訪問任何位置的元素。
3. 節約空間： 相對于LinkedList，ArrayList在存儲元素時通常占用更少的空間。

缺點:

1. 插入和刪除操作慢：對于大型列表，插入和刪除操作的性能較低，因為需要移動元素來維護連續性。
2. 擴容： 當ArrayList達到其容量限制時，需要進行擴容操作，這可能導致性能損失。
3. 不適合頻繁的插入和刪除操作： 如果需要頻繁執行插入和刪除操作，ArrayList的性能可能會受到影響。

LinkedList 的優缺點：
優點:

1. 插入和刪除操作快速： LinkedList基于鏈表實現，在插入和刪除操作時效率較高，因為只需要改變指針而不需要移動元素。
2. 適合頻繁的插入和刪除操作： 如果需要頻繁執行插入和刪除操作，LinkedList可能比ArrayList更適合。
3. 迭代器性能： 在迭代器遍歷過程中，LinkedList的性能優于ArrayList。

缺點

1. 隨機訪問慢： LinkedList不支持隨機訪問，訪問特定位置的元素可能需要遍歷列表，因此隨機訪問效率較低。
2. 占用更多空間： 相對于ArrayList，LinkedList在存儲元素時可能占用更多的空間，因為需要額外的指針來連接節點。

List 的實現類之三：Vector

• Vector 是一個古老的集合，JDK1.0 就有了。大多數操作與 ArrayList 相同，區別之處在于 Vector 是線程安全的。

• 在各種 List 中，最好把 ArrayList 作為默認選擇。當插入、刪除頻繁時，使用LinkedList；Vector 總是比 ArrayList 慢，所以盡量避免使用。

• 特有方法：

  • void addElement(Object obj)
  • void insertElementAt(Object obj,int index)
  • void setElementAt(Object obj,int index)
  • void removeElement(Object obj)
  • void removeAllElements()

2. Set接口

• Set 接口是 Collection 的子接口，Set 接口相較于 Collection 接口沒有提供額外的方法。
• Set 集合不允許包含相同的元素，如果試把兩個相同的元素加入同一個 Set 集合中，則添加操作失敗。
• Set 集合支持的遍歷方式和 Collection 集合一樣：foreach 和 Iterator。
• Set 的常用實現類有：HashSet、TreeSet、LinkedHashSet。

Set 主要實現類：HashSet

• HashSet 是 Set 接口的主要實現類，大多數時候使用 Set 集合時都使用這個實現類。
• HashSet 按 Hash 算法來存儲集合中的元素，因此具有很好的存儲、查找、刪除性能。
• HashSet 具有以下特點:
  • 不能保證元素的排列順序(使用元素的Hashcode值作為index存儲)
  • HashSet 不是線程安全的
  • 集合元素可以是 null
• HashSet 集合判斷兩個元素相等的標準：兩個對象通過 hashCode() 方法得到的哈希值相等，并且兩個對象的 equals()方法返回值為 true。
• 對于存放在 Set 容器中的對象，對應的類一定要重寫 hashCode()和 equals(Object obj)方法，以實現對象相等規則。即：“相等的對象必須具有相等的散列碼”。
• HashSet 集合中元素的無序性，不等同于隨機性。這里的無序性與元素的添加位置有關。具體來說：我們在添加每一個元素到數組中時，具體的存儲位置是由元素的hashCode()調用后返回的 hash 值決定的。導致在數組中每個元素不是依次緊密存放的，表現出一定的無序性。

---

HashSet添加元素的過程:

第 1 步：當向 HashSet 集合中存入一個元素時，HashSet 會調用該對象的hashCode() 方法得到該對象的 hashCode 值，然后根據 hashCode 值，通過某個散列函數決定該對象在 HashSet 底層數組中的存儲位置。

第 2 步：如果要在數組中存儲的位置上沒有元素，則直接添加成功。元素會保存在底層數組中。

第 3 步：如果要在數組中存儲的位置上有元素，則繼續比較：

• 如果兩個元素的 hashCode 值不相等，則添加成功；
• 如果兩個元素的 hashCode()值相等，則會繼續調用 equals()方法：
  • 如果 equals()方法結果為 false，則添加成功。由于該底層數組的位置已經有元素
    了，則會通過鏈表的方式繼續鏈接，存儲。
  • 如果 equals()方法結果為 true，則添加失敗

重寫 hashCode() 方法的基本原則:

1. 在程序運行時，同一個對象多次調用 hashCode() 方法應該返回相同的值。
2. 當兩個對象的 equals() 方法比較返回 true 時，這兩個對象的 hashCode() 方法的返回值也應相等。
3. 對象中用作 equals() 方法比較的 Field，都應該用來計算 hashCode 值。

重寫 equals()方法的基本原則:

1. 重寫 equals 方法的時候一般都需要同時復寫 hashCode 方法。通常參與計算hashCode 的對象的屬性也應該參與到 equals()中進行計算。
2. 推薦：開發中直接調用 Eclipse/IDEA 里的快捷鍵自動重寫 equals()和 hashCode()方法即可。

為什么用 Eclipse/IDEA 復寫 hashCode 方法，有 31 這個數字？
首先，選擇系數的時候要選擇盡量大的系數。因為如果計算出來的 hash 地址越大，所謂的“沖突”就越少，查找起來效率也會提高。（減少沖突）

其次，31 只占用 5bits,相乘造成數據溢出的概率較小。

再次，31 可以 由 i*31== (i<<5)-1 來表示,現在很多虛擬機里面都有做相關優化。（提高算法效率）

最后，31 是一個素數，素數作用就是如果我用一個數字來乘以這個素數，那么最終出來的結果只能被素數本身和被乘數還有 1 來整除！(減少沖突)

Set 實現類之二：LinkedHashSet

LinkedHashSet 是 HashSet 的子類，不允許集合元素重復。

LinkedHashSet 根據元素的 hashCode 值來決定元素的存儲位置，但它同時使用雙向鏈表維護元素的次序，這使得元素看起來是以添加順序保存的。

LinkedHashSet 插入性能略低于 HashSet，但在迭代訪問 Set 里的全部元素時有很好的性能。

Set 實現類之三：TreeSet

• TreeSet 是 SortedSet 接口的實現類，TreeSet 可以按照添加的元素的指定的屬性的大小順序進行遍歷。

• TreeSet 底層使用紅黑樹結構存儲數據

• TreeSet 特點：不允許重復、實現排序（自然排序或定制排序）

• TreeSet 兩種排序方法：自然排序和定制排序。默認情況下，TreeSet 采用自然排序。

  • 自然排序：TreeSet 會調用集合元素的 compareTo(Object obj) 方法來比較元素之間的大小關系，然后將集合元素按升序(默認情況)排列。
    • 如果試圖把一個對象添加到 TreeSet 時，則該對象的類必須實現Comparable 接口。
    • 實現 Comparable 的類必須實現 compareTo(Object obj) 方法，兩個對象即通過 compareTo(Object obj) 方法的返回值來比較大小。
  • 定制排序：如果元素所屬的類沒有實現 Comparable 接口，或不希望按照升序(默認情況)的方式排列元素或希望按照其它屬性大小進行排序，則考慮使用定制排序。定制排序，通過 Comparator接口來實現。需要重寫compare(T o1,T o2)方法。
    • 利用 int compare(T o1,T o2)方法，比較 o1 和 o2 的大小：如果方法返回正整數，則表示 o1 大于 o2；如果返回 0，表示相等；返回負整數，表示 o1 小于 o2。
    • 要實現定制排序，需要將實現 Comparator 接口的實例作為形參傳遞給 TreeSet 的構造器。

• 因為只有相同類的兩個實例才會比較大小，所以向 TreeSet 中添加的應該是同一個類的對象。

• 對于 TreeSet 集合而言，它判斷兩個對象是否相等的唯一標準是：兩個對象通過compareTo(Object obj) 或 compare(Object o1,Object o2)方法比較返回值。返回值為 0，則認為兩個對象相等。

三、Map的接口和方法

• Map 與 Collection 并列存在。用于保存具有映射關系的數據：key-value
  • Collection 集合稱為單列集合，元素是孤立存在的（理解為單身）。
  • Map 集合稱為雙列集合，元素是成對存在的(理解為夫妻)。
• Map 中的 key 和 value 都可以是任何引用類型的數據。但常用 String 類作為 Map的“鍵”。
• Map 接口的常用實現類：HashMap、LinkedHashMap、TreeMap 和Properties。其中，HashMap 是 Map 接口使用頻率最高的實現類。
  

1. Map中Key和Value的特點

這里主要以 HashMap 為例說明。HashMap 中存儲的 key、value 的特點如下:

Map 中的 key 用 Set 來存放，不允許重復，即同一個 Map 對象所對應的類，須重寫 hashCode()和 equals()方法

• key 和 value 之間存在單向一對一關系，即通過指定的 key 總能找到唯一的、確定的 value，不同 key 對應的 value 可以重復。value 所在的類要重寫 equals()方法。
• key 和 value 構成一個 entry。所有的 entry 彼此之間是無序的、不可重復的。

2. Map接口的常用方法

• 添加、修改操作：
  • Object put(Object key,Object value)：將指定 key-value 添加到(或修改)當前map 對象中
  • void putAll(Map m):將 m 中的所有 key-value 對存放到當前 map 中
• 刪除操作：
  • Object remove(Object key)：移除指定 key 的 key-value 對，并返回 value
  • void clear()：清空當前 map 中的所有數據
• 元素查詢的操作：
  • Object get(Object key)：獲取指定 key 對應的 value
  • boolean containsKey(Object key)：是否包含指定的 key
  • boolean containsValue(Object value)：是否包含指定的 value
  • int size()：返回 map 中 key-value 對的個數
  • boolean isEmpty()：判斷當前 map 是否為空
  • boolean equals(Object obj)：判斷當前 map 和參數對象 obj 是否相等
• 元視圖操作的方法：
  • Set keySet()：返回所有 key 構成的 Set 集合
  • Collection values()：返回所有 value 構成的 Collection 集合
  • Set entrySet()：返回所有 key-value 對構成的 Set 集合

3. Map 的主要實現類：HashMap

• HashMap 是 Map 接口使用頻率最高的實現類。
• HashMap 是線程不安全的。允許添加 null 鍵和 null 值。
• 存儲數據采用的哈希表結構，底層使用一維數組+單向鏈表+紅黑樹進行 key-value數據的存儲。與 HashSet 一樣，元素的存取順序不能保證一致。
• HashMap 判斷兩個 key 相等的標準是：兩個 key 的 hashCode 值相等，通過equals() 方法返回 true。
• HashMap 判斷兩個 value 相等的標準是：兩個 value 通過 equals() 方法返回true。

舉栗說明:

public static void main(String[] args) {HashMap map = new HashMap();map.put("許仙", "白娘子");map.put("董永", "七仙女");map.put("牛郎", "織女");map.put("許仙", "小青");System.out.println("所有的 key:");Set keySet = map.keySet();for (Object key : keySet) {System.out.println(key);}System.out.println("所有的 value:");Collection values = map.values();for (Object value : values) {System.out.println(value);}System.out.println("所有的映射關系:");Set entrySet = map.entrySet();for (Object mapping : entrySet) {//System.out.println(entry);Map.Entry entry = (Map.Entry) mapping;System.out.println(entry.getKey() + "->" + entry.getValue());}
}

4. Map 實現類之二：LinkedHashMap

? LinkedHashMap 是 HashMap 的子類
? 存儲數據采用的哈希表結構+鏈表結構，在 HashMap 存儲結構的基礎上，使用了一對雙向鏈表來記錄添加元素的先后順序，可以保證遍歷元素時，與添加的順序一致。

• 通過哈希表結構可以保證鍵的唯一、不重復，需要鍵所在類重寫 hashCode()方法、equals()方法。

5. Map 實現類之三：TreeMap

• TreeMap 存儲 key-value 對時，需要根據 key-value 對進行排序。TreeMap 可以保
  證所有的 key-value 對處于有序狀態。
• TreeSet 底層使用紅黑樹結構存儲數據
• TreeMap 的 Key 的排序：
  • 自然排序：TreeMap 的所有的 Key 必須實現 Comparable 接口，而且所有的 Key 應該是同一個類的對象，否則將會拋出 ClasssCastException
  • 定制排序：創建 TreeMap 時，構造器傳入一個 Comparator 對象，該對象負責對 TreeMap 中的所有 key 進行排序。此時不需要 Map 的 Key 實現 Comparable 接口
  • TreeMap 判斷兩個 key 相等的標準：兩個 key 通過 compareTo()方法或者 compare()方法返回 0。

舉個栗子:

public class TestTreeMap {/** 自然排序舉例* */@Testpublic void test1(){TreeMap map = new TreeMap();map.put("CC",45);map.put("MM",78);map.put("DD",56);map.put("GG",89);map.put("JJ",99);Set entrySet = map.entrySet();for(Object entry : entrySet){System.out.println(entry);}}/** 定制排序** */@Testpublic void test2(){//按照 User 的姓名的從小到大的順序排列TreeMap map = new TreeMap(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;return u1.name.compareTo(u2.name);}throw new RuntimeException("輸入的類型不匹配");}});map.put(new User("Tom",12),67);map.put(new User("Rose",23),"87");map.put(new User("Jerry",2),88);map.put(new User("Eric",18),45);map.put(new User("Tommy",44),77);map.put(new User("Jim",23),88);map.put(new User("Maria",18),34);Set entrySet = map.entrySet();for(Object entry : entrySet){System.out.println(entry);}}
}
class User implements Comparable{String name;int age;public User(String name, int age) {this.name = name;this.age = age;}public User() {}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}/*舉例：按照 age 從小到大的順序排列，如果 age 相同，則按照 name 從大到小的
順序排列* */@Overridepublic int compareTo(Object o) {if(this == o){return 0;}if(o instanceof User){User user = (User)o;int value = this.age - user.age;if(value != 0){return value;}return -this.name.compareTo(user.name);}throw new RuntimeException("輸入的類型不匹配");}
}

6. Map 實現類之四：Hashtable

• Hashtable 是 Map 接口的古老實現類，JDK1.0 就提供了。不同于 HashMap，Hashtable 是線程安全的。
• Hashtable 實現原理和 HashMap 相同，功能相同。底層都使用哈希表結構（數組+單向鏈表），查詢速度快。
• 與 HashMap 一樣，Hashtable 也不能保證其中 Key-Value 對的順序。
• Hashtable 判斷兩個 key 相等、兩個 value 相等的標準，與 HashMap 一致。
• 與 HashMap 不同，Hashtable 不允許使用 null 作為 key 或 value。

Hashtable 和 HashMap 的區別

HashMap:底層是一個哈希表（jdk7:數組+鏈表;jdk8:數組+鏈表+紅黑樹）,是一個線程不安全的集合,執行效率高
Hashtable:底層也是一個哈希表（數組+鏈表）,是一個線程安全的集合,執行效率低

HashMap 集合:可以存儲 null 的鍵、null 的值
Hashtable 集合,不能存儲 null 的鍵、null 的值
Hashtable 和 Vector 集合一樣,在 jdk1.2 版本之后被更先進的集合(HashMap,Arra
yList)取代了。所以 HashMap 是 Map 的主要實現類，Hashtable 是 Map 的古老實現類。

Hashtable 的子類 Properties（配置文件）依然活躍在歷史舞臺
Properties 集合是一個唯一和 IO 流相結合的集合

7. Map 實現類之五：Properties

• Properties 類是 Hashtable 的子類，該對象用于處理屬性文件
• 由于屬性文件里的 key、value 都是字符串類型，所以 Properties 中要求 key 和value 都是字符串類型
• 存取數據時，建議使用 setProperty(String key,String value)方法和 getProperty(String key)方法

舉個栗子:

@Test
public void test01() {Properties properties = System.getProperties();String fileEncoding = properties.getProperty("file.encoding");//
當前源文件字符編碼System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void test02() {Properties properties = new Properties();properties.setProperty("user","songhk");properties.setProperty("password","123456");System.out.println(properties);
}
@Test
public void test03() throws IOException {Properties pros = new Properties();pros.load(new FileInputStream("jdbc.properties"));String user = pros.getProperty("user");System.out.println(user);
}

四、Collections工具類

Collections 中提供了一系列靜態的方法對集合元素進行排序、查詢和修改等操作，還提供了對集合對象設置不可變、對集合對象實現同步控制等方法（均為static 方法）：

• 排序操作

  • reverse(List)：反轉 List 中元素的順序
  • shuffle(List)：對 List 集合元素進行隨機排序
  • sort(List)：根據元素的自然順序對指定 List 集合元素按升序排序
  • sort(List，Comparator)：根據指定的 Comparator 產生的順序對 List 集合元素進行排序
  • swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進行交換

• 查找

  • Object max(Collection)：根據元素的自然順序，返回給定集合中的最大元素
  • Object max(Collection，Comparator)：根據 Comparator 指定的順序，返回給定集合中的最大元素
  • Object min(Collection)：根據元素的自然順序，返回給定集合中的最小元素
  • Object min(Collection，Comparator)：根據 Comparator 指定的順序，返回給定集合中的最小元素
  • int binarySearch(List list,T key)在 List 集合中查找某個元素的下標，但是 List 的元素必須是 T 或 T 的子類對象，而且必須是可比較大小的，即支持自然排序的。而且集合也事先必須是有序的，否則結果不確定。
  • int frequency(Collection c，Object o)：返回指定集合中指定元素的出現次數

• 復制、替換

  • void copy(List dest,List src)：將 src 中的內容復制到 dest 中
  • boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替換 List 對象的所有舊值
  • 提供了多個 unmodifiableXxx()方法，該方法返回指定 Xxx 的不可修改的視圖。

• 添加

  • boolean addAll(Collection c,T… elements)將所有指定元素添加到指定 collection 中。

• 同步

  • Collections 類中提供了多個 synchronizedXxx() 方法，該方法可使將指定集合包裝成線程同步的集合，從而可以解決多線程并發訪問集合時的線程安全問題：
    

舉個大栗子:

package com.atguigu.collections;
import org.junit.Test;
import java.text.Collator;
import java.util.*;
public class TestCollections {@Testpublic void test01(){/*public static <T> boolean addAll(Collection<? super T> c,T... 
elements)將所有指定元素添加到指定 collection 中。Collection 的集合的元素類
型必須>=T 類型*/Collection<Object> coll = new ArrayList<>();Collections.addAll(coll, "hello","java");Collections.addAll(coll, 1,2,3,4);Collection<String> coll2 = new ArrayList<>();Collections.addAll(coll2, "hello","java");//Collections.addAll(coll2, 1,2,3,4);//String 和 Integer 之間沒
有父子類關系}
@Testpublic void test02(){
/*
* public static <T extends Object & Comparable<? super T>> T max(Col
lection<? extends T> coll)
* 在 coll 集合中找出最大的元素，集合中的對象必須是 T 或 T 的子類對象，而且支
持自然排序
* 
* public static <T> T max(Collection<? extends T> coll,Comparator<? 
super T> comp)
* 在 coll 集合中找出最大的元素，集合中的對象必須是 T 或 T 的子類對象，按照比
較器 comp 找出最大者
*
*/List<Man> list = new ArrayList<>();list.add(new Man("張三",23));list.add(new Man("李四",24));list.add(new Man("王五",25));/** Man max = Collections.max(list);//要求 Man 實現 Comparable 接
口，或者父類實現* System.out.println(max);*/Man max = Collections.max(list, new Comparator<Man>() {@Overridepublic int compare(Man o1, Man o2) {return o2.getAge()-o2.getAge();}});System.out.println(max);}
@Testpublic void test03(){/** public static void reverse(List<?> list)* 反轉指定列表 List 中元素的順序。*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");System.out.println(list);Collections.reverse(list);System.out.println(list);}
@Testpublic void test04(){/* public static void shuffle(List<?> list) * List 集合元素進行隨機排序，類似洗牌，打亂順序*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");Collections.shuffle(list);System.out.println(list);}
@Testpublic void test05() {/* public static <T extends Comparable<? super T>> void sort(L
ist<T> list)* 根據元素的自然順序對指定 List 集合元素按升序排序* public static <T> void sort(List<T> list,Comparator<? super
T> c)* 根據指定的 Comparator 產生的順序對 List 集合元素進行排序*/List<Man> list = new ArrayList<>();list.add(new Man("張三",23));list.add(new Man("李四",24));list.add(new Man("王五",25));Collections.sort(list);System.out.println(list);Collections.sort(list, new Comparator<Man>() {@Overridepublic int compare(Man o1, Man o2) {return Collator.getInstance(Locale.CHINA).compare(o1.g
etName(),o2.getName());}});System.out.println(list);}
@Testpublic void test06(){/* public static void swap(List<?> list,int i,int j)* 將指定 list 集合中的 i 處元素和 j 處元素進行交換*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");Collections.swap(list,0,2);System.out.println(list);}
@Testpublic void test07(){/* public static int frequency(Collection<?> c,Object o)* 返回指定集合中指定元素的出現次數*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world","hello","hello
");int count = Collections.frequency(list, "hello");System.out.println("count = " + count);}
@Testpublic void test08(){/* public static <T> void copy(List<? super T> dest,List<? ext
ends T> src)* 將 src 中的內容復制到 dest 中*/List<Integer> list = new ArrayList<>();for(int i=1; i<=5; i++){//1-5list.add(i);}List<Integer> list2 = new ArrayList<>();for(int i=11; i<=13; i++){//11-13list2.add(i);}Collections.copy(list, list2);System.out.println(list);List<Integer> list3 = new ArrayList<>();for(int i=11; i<=20; i++){//11-20list3.add(i);}
//java.lang.IndexOutOfBoundsException: Source does not fit in 
dest//Collections.copy(list, list3);//System.out.println(list);}
@Testpublic void test09(){/*public static <T> boolean replaceAll(List<T> list，T oldVa
l，T newVal)* 使用新值替換 List 對象的所有舊值*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world","hello","hello
");Collections.replaceAll(list, "hello","song");System.out.println(list);}
}