Java中的集合(下)
### 11.3.3 List實現類的區別
#### 1、Vector和ArrayList的區別
核心類庫中List接口有兩個實現類：Vector和ArrayList。它們的底層物理結構都是數組，我們稱為動態數組。
（1）ArrayList是新版的動態數組，線程不安全，效率高，Vector是舊版的動態數組，線程安全，效率低。
（2）動態數組的擴容機制不同，ArrayList擴容為原來的1.5倍，Vector擴容增加為原來的2倍。
（3）數組的初始化容量，如果在構建ArrayList與Vector的集合對象時，沒有顯式指定初始化容量，那么Vector的內部數組的初始容量默認為10，而ArrayList在JDK1.6及之前的版本也是10，JDK1.7之后的版本ArrayList初始化為長度為0的空數組，之后在添加第一個元素時，再創建長度為10的數組。
ArrayList在第1次添加時再創建數組是為了避免浪費。因為很多方法的返回值是ArrayList類型，需要返回一個ArrayList的對象，例如：后期從數據庫查詢對象的方法，返回值很多就是ArrayList。有可能你要查詢的數據不存在，要么返回null，要么返回一個沒有元素的ArrayList對象。
#### 2、ArrayList與LinkedList的區別
動態數組底層的物理結構是數組，因此根據索引訪問的效率非常高。但是==非末尾==位置的插入和刪除效率不高，因為涉及到移動元素。==末尾位置==的插入和刪除不涉及移動元素。另外添加操作時涉及到擴容問題，就會增加時空消耗。
鏈表底層的物理結構是鏈表，因此根據索引訪問的效率不高，但是插入和刪除不需要移動元素，只需要修改前后元素的指向關系即可，而且鏈表的添加不會涉及到擴容問題。
## 11.4 棧和隊列
### 11.4.1 棧
堆棧是一種先進后出（FILO：first in last out）或后進先出（LIFO：last in first out）的結構。
棧只是邏輯結構，其物理結構可以是數組，也可以是鏈表，即棧結構分為順序棧和鏈式棧。
核心類庫中的棧結構有Stack和LinkdeList。Stack就是順序棧，它是Vector的子類。LinkedList是鏈式棧。
體現棧結構的操作方法：
* peek()方法：查看棧頂元素，不彈出
* pop()方法：彈出棧
* push(E e)方法：壓入棧
```java
package com.atguigu.list;
import org.junit.Test;
import java.util.LinkedList;
import java.util.Stack;
public class TestStack {
@Test
public void test1(){
Stack<Integer> list = new Stack<>();
list.push(1);
list.push(2);
list.push(3);
System.out.println("list = " + list);
System.out.println("list.peek()=" + list.peek());
System.out.println("list.peek()=" + list.peek());
System.out.println("list.peek()=" + list.peek());
/*
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());//java.util.NoSuchElementException
*/
while(!list.empty()){
System.out.println("list.pop() =" + list.pop());
}
}
@Test
public void test2(){
LinkedList<Integer> list = new LinkedList<>();
list.push(1);
list.push(2);
list.push(3);
System.out.println("list = " + list);
System.out.println("list.peek()=" + list.peek());
System.out.println("list.peek()=" + list.peek());
System.out.println("list.peek()=" + list.peek());
/*
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());
System.out.println("list.pop() =" + list.pop());//java.util.NoSuchElementException
*/
while(!list.isEmpty()){
System.out.println("list.pop() =" + list.pop());
}
}
}
```### 11.4.2 隊列
隊列（Queue）是一種（但并非一定）先進先出（FIFO）的結構。
隊列是邏輯結構，其物理結構可以是數組，也可以是鏈表。隊列有普通隊列、雙端隊列、并發隊列等等，核心類庫中的隊列實現類有很多（后面會學到很多），LinkdeList是雙端隊列的實現類。
==Queue==除了基本的 `Collection`操作外，==隊列==還提供其他的插入、提取和檢查操作。每個方法都存在兩種形式：一種拋出異常（操作失敗時），另一種返回一個特殊值（`null` 或 `false`，具體取決于操作）。`Queue` 實現通常不允許插入 元素，盡管某些實現（如 ）并不禁止插入 。即使在允許 null 的實現中，也不應該將 插入到 中，因為 也用作 方法的一個特殊返回值，表明隊列不包含元素。
| | *拋出異常* | *返回特殊值* |
| ---- | ---------- | ------------ |
| 插入 | add(e) | offer(e) |
| 移除 | remove() | poll() |
| 檢查 | element() | peek() |
==Deque==，名稱 *deque* 是“double ended queue==（雙端隊列）==”的縮寫，通常讀為“deck”。此接口定義在雙端隊列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操作失敗時拋出異常，另一種形式返回一個特殊值（`null` 或 `false`，具體取決于操作）。Deque接口的實現類有ArrayDeque和LinkedList，它們一個底層是使用數組實現，一個使用雙向鏈表實現。
| | **第一個元素（頭部）** | | **最后一個元素（尾部）** | |
| -------- | ---------------------- | ------------- | ------------------------ | ------------ |
| | *拋出異常* | *特殊值* | *拋出異常* | *特殊值* |
| **插入** | addFirst(e) | offerFirst(e) | addLast(e) | offerLast(e) |
| **移除** | removeFirst() | pollFirst() | removeLast() | pollLast() |
| **檢查** | getFirst() | peekFirst() | getLast() | peekLast() |
此接口擴展了 `Queue`接口。在將雙端隊列用作隊列時，將得到 FIFO（先進先出）行為。將元素添加到雙端隊列的末尾，從雙端隊列的開頭移除元素。從 `Queue` 接口繼承的方法完全等效于 `Deque` 方法，如下表所示：
| **`Queue` 方法** | **等效 `Deque` 方法** |
| ---------------- | --------------------- |
| add(e) | addLast(e) |
| offer(e) | offerLast(e) |
| remove() | removeFirst() |
| poll() | pollFirst() |
| element() | getFirst() |
| peek() | peekFirst() |
雙端隊列也可用作 LIFO（后進先出）堆棧。應優先使用此接口而不是遺留 `Stack` 類。在將雙端隊列用作堆棧時，元素被推入雙端隊列的開頭并從雙端隊列開頭彈出。堆棧方法完全等效于 `Deque` 方法，如下表所示：
| **堆棧方法** | **等效 `Deque` 方法** |
| ------------ | --------------------- |
| push(e) | addFirst(e) |
| pop() | removeFirst() |
| peek() | peekFirst() |
結論：Deque接口的實現類既可以用作FILO堆棧使用，又可以用作FIFO隊列使用。
```java
package com.atguigu.queue;
import java.util.LinkedList;
public class TestQueue {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.addLast("張三");
list.addLast("李四");
list.addLast("王五");
list.addLast("趙六");
while (!list.isEmpty()){
System.out.println("list.removeFirst()=" + list.removeFirst());
}
}
}
```
## 11.5 Map
### 11.5.1 概述
現實生活中，我們常會看到這樣的一種集合：IP地址與主機名，身份證號與個人，系統用戶名與系統用戶對象等，這種一一對應的關系，就叫做映射。Java提供了專門的集合類用來存放這種對象關系的對象，即`java.util.Map<K,V>`接口。Map接口的常用實現類：HashMap、TreeMap、LinkedHashMap和Properties。其中HashMap是 Map 接口使用頻率最高的實現類。
我們通過查看`Map`接口描述，發現`Map<K,V>`接口下的集合與`Collection<E>`接口下的集合，它們存儲數據的形式不同。
* `Collection`中的集合，元素是孤立存在的（理解為單身），向集合中存儲元素采用一個個元素的方式存儲。
* `Map`中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值。
* `Collection`中的集合稱為單列集合，`Map`中的集合稱為雙列集合。
* 需要注意的是，`Map`中的集合不能包含重復的鍵，值可以重復；每個鍵只能對應一個值（這個值可以是單個值，也可以是個數組或集合值）。
### 11.5.2 Map常用方法
1、添加操作
* V put(K key,V value)：添加一對鍵值對
* void putAll(Map<? extends K,? extends V> m)：添加一組鍵值對
2、刪除
* void clear()：清空map
* V remove(Object key)：根據key刪除一對鍵值對
* default boolean remove(Object key,Object value)：刪除匹配的(key,value)
3、修改value（JDK1.8新增）
- default V replace(K key, V value)：找到目標key，替換value
- default boolean replace(K key,V oldValue,V newValue)：找到目標(key,value)，替換value
- default void replaceAll(BiFunction<? super K,? super V,? extends V> function)：按照指定要求替換value
4、元素查詢的操作
* V get(Object key)：根據key返回value
* boolean containsKey(Object key)：判斷key是否存在
* boolean containsValue(Object value)：判斷value是否存在
* boolean isEmpty()：判斷map是否為空
* int size()：獲取鍵值對的數量
5、遍歷
Map的遍歷，不能支持foreach，因為Map接口沒有繼承java.lang.Iterable<T>接口。只能用如下方式遍歷：
（1）分開遍歷：
* 單獨遍歷所有key：Set<K> keySet()
* 單獨遍歷所有value：Collection<V> values()
（2）成對遍歷：
* 遍歷所有鍵值對：Set<Map.Entry<K,V>> entrySet()
* 遍歷的是映射關系Map.Entry類型的對象，Map.Entry是Map接口的內部接口。每一種Map內部有自己的Map.Entry的實現類。在Map中存儲數據，實際上是將Key---->value的數據存儲在Map.Entry接口的實例中，再在Map集合中插入Map.Entry的實例化對象，如圖示：
（3）調用forEach方法遍歷
- default void forEach(BiConsumer<? super K,? super V> action)
```java
package com.atguigu.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.function.BiFunction;
public class TestMapMethod {
@Test
public void test1(){
//創建 map對象
HashMap<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("黃曉明", "楊穎");
map.put("文章", "馬伊琍");
map.put("文章", "姚笛");
map.put("鄧超", "孫儷");
System.out.println(map.size());
System.out.println(map);
}
@Test
public void test2(){
HashMap<String, String> map = new HashMap<String, String>();
//添加模范夫妻
map.put("黃曉明", "楊穎");
map.put("文章", "馬伊琍");
map.put("鄧超", "孫儷");
System.out.println(map);
//刪除鍵值對
map.remove("文章");
System.out.println(map);
map.remove("黃曉明","楊穎");
System.out.println(map);
}
@Test
public void test3(){
HashMap<String, String> map = new HashMap<String, String>();
//添加夫妻
map.put("黃曉明", "楊穎");
map.put("文章", "馬伊琍");
map.put("鄧超", "孫儷");
map.put("張三", null);
System.out.println(map);
//修改value
map.replace("文章","姚笛");
System.out.println(map);
map.replace("黃曉明","楊穎", "angelababy");
System.out.println(map);
map.replaceAll(new BiFunction<String, String, String>() {
@Override
public String apply(String key, String value) {
return value == null ? "如花" : value;
}
});
System.out.println(map);
}
@Test
public void test4(){
HashMap<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("黃曉明", "楊穎");
map.put("文章", "馬伊琍");
map.put("鄧超", "孫儷");
// 想要查看 誰的媳婦 是誰
System.out.println(map.get("黃曉明"));
System.out.println(map.get("鄧超"));
}
@Test
public void test4(){
HashMap<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("黃曉明", "楊穎");
map.put("文章", "馬伊琍");
map.put("鄧超", "孫儷");
//遍歷所有key
System.out.println("所有key：");
Set<String> keySet = map.keySet();
for (String key : keySet) {
System.out.println(key);
}
//遍歷所有value
System.out.println("所有value：");
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
//遍歷所有鍵值對
System.out.println("所有鍵值對：");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry);
}
//調用forEach方法遍歷所有鍵值對
System.out.println("所有鍵值對：");
BiConsumer<String,String> c = new BiConsumer<>() {
@Override
public void accept(String key, String value) {
System.out.println(key+" vs "+value);
}
};
map.forEach(c);
}
}
```### 11.5.3 Map接口的實現類們
#### **1、HashMap和Hashtable**
HashMap和Hashtable都是哈希表。HashMap和Hashtable判斷兩個 key 相等的標準是：兩個 key 的hashCode 值相等，并且 equals() 方法也返回 true。因此，為了成功地在哈希表中存儲和獲取對象，用作鍵的對象必須實現 hashCode 方法和 equals 方法。
* Hashtable是線程安全的，任何非 null 對象都可以用作鍵或值。
* HashMap是線程不安全的，并允許使用 null 值和 null 鍵。
示例代碼：添加員工姓名為key，薪資為value
```java
package com.atguigu.map;
import org.junit.Test;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
public class TestHashMap {
@Test
public void test01(){
HashMap<String,Double> map = new HashMap<>();
map.put("張三", 10000.0);
//key相同，新的value會覆蓋原來的value
//因為String重寫了hashCode和equals方法
map.put("張三", 12000.0);
map.put("李四", 14000.0);
//HashMap支持key和value為null值
String name = null;
Double salary = null;
map.put(name, salary);
System.out.println(map);
}
@Test
public void test02(){
Hashtable<String,Double> map = new Hashtable<>();
map.put("張三", 10000.0);
//key相同，新的value會覆蓋原來的value
//因為String重寫了hashCode和equals方法
map.put("張三", 12000.0);
map.put("李四", 14000.0);
//Hashtable不支持key和value為null值
/*String name = null;
Double salary = null;
map.put(name, salary);*/
System.out.println(map);
}
}
```#### **2、LinkedHashMap**
LinkedHashMap 是 HashMap 的子類。此實現與 HashMap 的不同之處在于，后者維護著一個運行于所有條目的雙重鏈接列表。此鏈接列表定義了迭代順序，該迭代順序通常就是將鍵插入到映射中的順序（插入順序）。
示例代碼：添加員工姓名為key，薪資為value
```java
package com.atguigu.map;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class TestLinkedHashMap {
public static void main(String[] args) {
LinkedHashMap<String,Double> map = new LinkedHashMap<>();
map.put("張三", 10000.0);
//key相同，新的value會覆蓋原來的value
//因為String重寫了hashCode和equals方法
map.put("張三", 12000.0);
map.put("李四", 14000.0);
//HashMap支持key和value為null值
String name = null;
Double salary = null;
map.put(name, salary);
System.out.println(map);
}
}
```#### **3、TreeMap**
基于紅黑樹（Red-Black tree）的 NavigableMap 實現。該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決于使用的構造方法。
代碼示例：添加員工姓名為key，薪資為value
```java
package com.atguigu.map;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import org.junit.Test;
public class TestTreeMap {
@Test
public void test1() {
TreeMap<String,Integer> map = new TreeMap<>();
map.put("Jack", 11000);
map.put("Alice", 12000);
map.put("zhangsan", 13000);
map.put("baitao", 14000);
map.put("Lucy", 15000);
//String實現了Comparable接口，默認按照Unicode編碼值排序
System.out.println(map);
}
@Test
public void test2() {
//指定定制比較器Comparator，按照Unicode編碼值排序，但是忽略大小寫
TreeMap<String,Integer> map = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareToIgnoreCase(o2);
}
});
map.put("Jack", 11000);
map.put("Alice", 12000);
map.put("zhangsan", 13000);
map.put("baitao", 14000);
map.put("Lucy", 15000);
System.out.println(map);
}
}
```#### **4、Properties**
Properties 類是 Hashtable 的子類，Properties 可保存在流中或從流中加載。屬性列表中每個鍵及其對應值都是一個字符串。
存取數據時，建議使用setProperty(String key,String value)方法和getProperty(String key)方法。
代碼示例：
```java
package com.atguigu.map;
import org.junit.Test;
import java.util.Properties;
public class TestProperties {
@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","chai");
properties.setProperty("password","123456");
System.out.println(properties);
}
}
```### 11.5.4 Set集合與Map集合的關系
Set的內部實現其實是一個Map。即HashSet的內部實現是一個HashMap，TreeSet的內部實現是一個TreeMap，LinkedHashSet的內部實現是一個LinkedHashMap。
部分源代碼摘要：
HashSet源碼：
```java
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
//這個構造器是給子類LinkedHashSet調用的
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
```LinkedHashSet源碼：
```java
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);//調用HashSet的某個構造器
}
public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);//調用HashSet的某個構造器
}
public LinkedHashSet() {
super(16, .75f, true);
}
public LinkedHashSet(Collection<? extends E> c) {
super(Math.max(2*c.size(), 11), .75f, true);//調用HashSet的某個構造器
addAll(c);
}
```TreeSet源碼：
```java
public TreeSet() {
this(new TreeMap<E,Object>());
}
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
```但是，咱們存到Set中只有一個元素，又是怎么變成(key,value)的呢？
以HashSet中的源碼為例：
```java
private static final Object PRESENT = new Object();
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public Iterator<E> iterator() {
return map.keySet().iterator();
}
```原來是，把添加到Set中的元素作為內部實現map的key，然后用一個常量對象PRESENT對象，作為value。
這是因為Set的元素不可重復和Map的key不可重復有相同特點。Map有一個方法keySet()可以返回所有key。
### 11.5.5 哈希表的原理分析
#### 1、二叉樹了解
二叉樹（Binary tree）是樹形結構的一個重要類型。二叉樹特點是每個結點最多只能有兩棵子樹，且有左右之分。許多實際問題抽象出來的數據結構往往是二叉樹形式，二叉樹的存儲結構及其算法都較為簡單，因此二叉樹顯得特別重要。
前序遍歷：ABDHIECFG
中序遍歷：HDIBEAFCG
后序遍歷：HIDEBFGCA
以下是幾種經典的二叉樹：
1、滿二叉樹： 除最后一層無任何子節點外，每一層上的所有結點都有兩個子結點的二叉樹。 第n層的結點數是2的n-1次方，總的結點個數是2的n次方-1
2、完全二叉樹： 葉結點只能出現在最底層的兩層，且最底層葉結點均處于次底層葉結點的左側。
3、平衡二叉樹：平衡二叉樹（Self-balancing binary search tree）又被稱為AVL樹（有別于AVL算法），且具有以下性質：它是一 棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，并且左右兩個子樹都是一棵平衡二叉樹， 但不要求非葉節點都有兩個子結點 。平衡二叉樹的常用實現方法有紅黑樹、AVL、替罪羊樹、Treap、伸展樹等。例如紅黑樹的要求：
- 節點是紅色或者黑色
- 根節點是黑色
- 每個葉子的節點都是黑色的空節點（NULL）
- 每個紅色節點的兩個子節點都是黑色的。
- 從任意節點到其每個葉子的所有路徑都包含相同的黑色節點數量。
當我們插入或刪除節點時，可能會破壞已有的紅黑樹，使得它不滿足以上5個要求，那么此時就需要進行處理：
1、recolor ：將某個節點變紅或變黑
2、rotation ：將紅黑樹某些結點分支進行旋轉（左旋或右旋）
使得它繼續滿足以上的5個要求。
例如：插入了結點21之后，紅黑樹處理成：
#### 2、 哈希表的數據結構
請看PPT
## 11.6 集合框架
## 11.7 Collections工具類
參考操作數組的工具類：Arrays。
Collections 是一個操作 Set、List 和 Map 等集合的工具類。Collections 中提供了一系列靜態的方法對集合元素進行排序、查詢和修改等操作，還提供了對集合對象設置不可變、對集合對象實現同步控制等方法：
* public static <T> boolean addAll(Collection<? super T> c,T... elements)將所有指定元素添加到指定 collection 中。
* public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)在List集合中查找某個元素的下標，但是List的元素必須是T或T的子類對象，而且必須是可比較大小的，即支持自然排序的。而且集合也事先必須是有序的，否則結果不確定。
* public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)在List集合中查找某個元素的下標，但是List的元素必須是T或T的子類對象，而且集合也事先必須是按照c比較器規則進行排序過的，否則結果不確定。
* public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)在coll集合中找出最大的元素，集合中的對象必須是T或T的子類對象，而且支持自然排序
* public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)在coll集合中找出最大的元素，集合中的對象必須是T或T的子類對象，按照比較器comp找出最大者
* public static void reverse(List<?> list)反轉指定列表List中元素的順序。
* public static void shuffle(List<?> list) List 集合元素進行隨機排序，類似洗牌
* public static <T extends Comparable<? super T>> void sort(List<T> list)根據元素的自然順序對指定 List 集合元素按升序排序
* public static <T> void sort(List<T> list,Comparator<? super T> c)根據指定的 Comparator 產生的順序對 List 集合元素進行排序
* public static void swap(List<?> list,int i,int j)將指定 list 集合中的 i 處元素和 j 處元素進行交換
* public static int frequency(Collection<?> c,Object o)返回指定集合中指定元素的出現次數
* public static <T> void copy(List<? super T> dest,List<? extends T> src)將src中的內容復制到dest中
* public static <T> boolean replaceAll(List<T> list，T oldVal，T newVal)：使用新值替換 List 對象的所有舊值
* Collections 類中提供了多個 synchronizedXxx() 方法，該方法可使將指定集合包裝成線程同步的集合，從而可以解決多線程并發訪問集合時的線程安全問題
* Collections類中提供了多個unmodifiableXxx()方法，該方法返回指定 Xxx的不可修改的視圖。
```java
package com.atguigu.collections;
import org.junit.Test;
import java.text.Collator;
import java.util.*;
public class TestCollections {
@Test
public void test11(){
/*
public static <T> boolean replaceAll(List<T> list，T oldVal，T newVal)：使用新值替換 List 對象的所有舊值
*/
List<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world","hello","hello");
Collections.replaceAll(list, "hello","chai");
System.out.println(list);
}
@Test
public void test10(){
List<Integer> list = new ArrayList<>();
for(int i=1; i<=5; i++){//1-5
list.add(i);
}
List<Integer> list2 = new ArrayList<>();
for(int i=11; i<=13; i++){//11-13
list2.add(i);
}
list.addAll(list2);
System.out.println(list);//[1, 2, 3, 4, 5, 11, 12, 13]
}
@Test
public void test09(){
/*
* public static <T> void copy(List<? super T> dest,List<? extends T> src)將src中的內容復制到dest中
*/
List<Integer> list = new ArrayList<>();
for(int i=1; i<=5; i++){//1-5
list.add(i);
}
List<Integer> list2 = new ArrayList<>();
for(int i=11; i<=13; i++){//11-13
list2.add(i);
}
Collections.copy(list, list2);
System.out.println(list);
List<Integer> list3 = new ArrayList<>();
for(int i=11; i<=20; i++){//11-20
list3.add(i);
}
Collections.copy(list, list3);//java.lang.IndexOutOfBoundsException: Source does not fit in dest
System.out.println(list);
}
@Test
public void test08(){
/*
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);
}
@Test
public void test07(){
/*
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);
}
@Test
public void test06() {
/*
* public static <T extends Comparable<? super T>> void sort(List<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>() {
@Override
public int compare(Man o1, Man o2) {
return Collator.getInstance(Locale.CHINA).compare(o1.getName(),o2.getName());
}
});
System.out.println(list);
}
@Test
public void test05(){
/*
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);
}
@Test
public void test04(){
/*
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);
}
@Test
public void test03(){
/*
* public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
* <T extends Object & Comparable<? super T>>：要求T必須繼承Object，又實現Comparable接口，或者T的父類實現Comparable接口
* 在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>() {
@Override
public int compare(Man o1, Man o2) {
return o2.getAge()-o2.getAge();
}
});
System.out.println(max);
}
@Test
public void test02(){
/*
* public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
* 要求List集合的元素類型 實現了 Comparable接口，這個實現可以是T類型本身也可以T的父類實現這個接口。
* 說明List中的元素支持自然排序功能。
* 在List集合中查找某個元素的下標，但是List的元素必須是T或T的子類對象，而且必須是可比較大小的，即支持自然排序的。而且集合也事先必須是有序的，否則結果不確定。
* public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)
* 說明List集合中元素的類型<=T，Comparator<? super T>說明要傳入一個Comparator接口的實現類對象，實現類泛型的指定要求>=T
* 例如：List中存儲的是Man（男）對象，T可以是Person類型，實現Comparator的時候可以是 Comparator<Person>
* 例如：List中存儲的是Man（男）對象，T可以是Man類型，實現Comparator的時候可以是 Comparator<Person>
* 在List集合中查找某個元素的下標，但是List的元素必須是T或T的子類對象，而且集合也事先必須是按照c比較器規則進行排序過的，否則結果不確定。
*
* 二分查找要求數組或List必須是“有大小順序”。
* 二分查找的思路： 和[mid]元素比較，如果相同，就找到了，不相同要看大小關系，決定去左邊還是右邊繼續查找。
*/
List<Man> list = new ArrayList<>();
list.add(new Man("張三",23));
list.add(new Man("李四",24));
list.add(new Man("王五",25));
// int index = Collections.binarySearch(list, new Man("王五", 25));//要求實現Comparable接口
// System.out.println(index);
int index = Collections.binarySearch(list, new Man("王五", 25), new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
System.out.println(index);
}
@Test
public 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之間沒有父子類關系
}
}
```## 11.8 Arrays工具類
public static <T> List<T> asList(T... a)：將指定元素添加到一個固定大小的列表中，并返回列表。
```java
@Test
public void test(){
List<String> list = Arrays.asList("hello", "java", "world");
System.out.println(list);
try {
list.add("chai");
} catch (Exception e) {
e.printStackTrace();
}
try {
list.remove("hello");
} catch (Exception e) {
e.printStackTrace();
}
}
```
