文章目錄

• 一 簡介
• 二 底層數(shù)據(jù)結(jié)構(gòu)總結(jié)
• • 1 List
  • 2 Set
  • 3 Queue
  • 4 Map
• 三 Collection 的子接口 List
• • 1 ArrayList 與 Vector
  • 2 ArrayList 與 LinkedList
  • 3 ArrayList 的 JDK 7/8 差異
  • 4 List 的 remove() 方法
  • 5 ArrayList 的構(gòu)造方法與擴容機制*
• 四 Collection 的子接口 Set
• • 1 Comparable 與 Comparator
  • 2 Set 的無序性
  • 3 HashSet、LinkedHashSet 和 TreeSet
  • 4 HashSet 加入實例時，查重的方式（類似實例間的相等比較）**
  • 5 HashSet 存儲原理的實例**
• 五 Collection 的子接口 Queue
• • 1 Queue 與 Deque
  • 2 PriorityQueue
  • 3 ArrayDeque 與 LinkedList
• 六 Collection 的子接口 Map
• • 1 HashMap 和 Hashtable
  • 2 HashMap 和 HashSet
  • 3 HashMap 的長度為什么是 2 的冪次方
  • 4 ConcurrentHashMap 和 Hashtable
  • 5 CAS (Compare And Swap)
  • 6 HashMap 的底層實現(xiàn)
  • 7 HashMap 底層實現(xiàn)的參數(shù)
  • 8 JDK 8 HashMap 的擴容
• 七 Iterator
• • 1 Iterator的使用方法
  • 2 遍歷中刪除元素
• 八 Collections 工具類的常用靜態(tài)方法

---

一 簡介

Java容器可大致分為 List、Queue、Set、Map 四種。

• List：存儲的元素是有序的、可重復(fù)的
• Set：存儲的元素是無序的、不可重復(fù)的
• Queue：按特定的排隊規(guī)則來確定先后順序，存儲的元素是有序的、可重復(fù)的
• Map：使用鍵值對（key-value）存儲，類似于數(shù)學(xué)上的函數(shù) y=f(x)，“x” 代表 key，“y” 代表 value，key 是無序的、不可重復(fù)的，value 是無序的、可重復(fù)的，每個鍵最多映射到一個值
  

---

二 底層數(shù)據(jù)結(jié)構(gòu)總結(jié)

使用紅黑樹的底層結(jié)構(gòu)，根本目的是增強數(shù)據(jù)結(jié)構(gòu)搜索和排序的能力

1 List

• Arraylist： Object[] 數(shù)組
• Vector：Object[] 數(shù)組
• LinkedList： 雙向鏈表(JDK1.6 之前為循環(huán)鏈表，JDK1.7 取消了循環(huán))

2 Set

• HashSet(無序，唯一)：底層采用 HashMap 來保存元素
• LinkedHashSet：LinkedHashSet 是 HashSet 的子類，并且其內(nèi)部是通過 LinkedHashMap 來實現(xiàn)的
• TreeSet(有序，唯一)：紅黑樹(自平衡的排序二叉樹)

3 Queue

• PriorityQueue: Object[] 數(shù)組來實現(xiàn)二叉堆
• ArrayQueue: Object[] 數(shù)組 + 雙指針

4 Map

• HashMap： JDK1.8 之前 HashMap 由數(shù)組+鏈表組成的，數(shù)組是 HashMap 的主體，鏈表則是主要為了解決哈希沖突而存在的（“拉鏈法”解決沖突）。JDK1.8 以后在解決哈希沖突時有了較大的變化，當(dāng)鏈表長度大于閾值（默認(rèn)為 8）（將鏈表轉(zhuǎn)換成紅黑樹前會判斷，如果當(dāng)前數(shù)組的長度小于 64，那么會選擇先進(jìn)行數(shù)組擴容，而不是轉(zhuǎn)換為紅黑樹）時，將鏈表轉(zhuǎn)化為紅黑樹，以減少搜索時間
  

• LinkedHashMap： LinkedHashMap 繼承自 HashMap，所以它的底層仍然是基于拉鏈?zhǔn)缴⒘薪Y(jié)構(gòu)即由數(shù)組和鏈表或紅黑樹組成。另外，LinkedHashMap 在上面結(jié)構(gòu)的基礎(chǔ)上，增加了一條雙向鏈表，使得上面的結(jié)構(gòu)可以 保持鍵值對的插入順序。同時通過對鏈表進(jìn)行相應(yīng)的操作，實現(xiàn)了訪問順序相關(guān)邏輯

• HashTable： 數(shù)組+鏈表組成的，數(shù)組是 HashTable 的主體，鏈表則是主要為了解決哈希沖突而存在的

• TreeMap： 紅黑樹（自平衡的排序二叉樹）

---

三 Collection 的子接口 List

1 ArrayList 與 Vector

• ArrayList 和 Vector 的底層都是 Object[ ] 存儲的，即對數(shù)組進(jìn)行封裝
• ArrayList 是 List 的主要實現(xiàn)類，適用于頻繁的查找工作，線程不安全
• Vector 是 List 的古老實現(xiàn)類，線程安全

2 ArrayList 與 LinkedList

• 都是線程不安全的
• ArrayList 底層使用 Object[ ] 存儲（支持隨機訪問），LinkedList 使用雙向鏈表存儲（不支持隨機訪問）。
• ArrayList 的空間浪費主要體現(xiàn)在列表的結(jié)尾會預(yù)留一定的容量空間，而 LinkedList 的空間花費則體現(xiàn)在它的每一個元素都需要消耗比 ArrayList 更多的空間（因為要存放直接后繼和直接前驅(qū)以及數(shù)據(jù)）
• 插入/刪除 元素時的時間復(fù)雜度不同，體現(xiàn)在數(shù)組與鏈表的區(qū)別

3 ArrayList 的 JDK 7/8 差異

• JDK 7

ArrayList list = new ArrayList();//底層創(chuàng)建了長度是*10*的Object[]數(shù)組elementData list.add(123);//elementData[0] = new Integer(123); list.add(11);//如果此次的添加導(dǎo)致底層elementData數(shù)組容量不夠，則擴容。/* 默認(rèn)情況下，擴容為原來的容量的1.5倍，同時需要將原有數(shù)組中的數(shù)據(jù)復(fù)制到新的數(shù)組中。 結(jié)論：建議開發(fā)中使用帶參的構(gòu)造器：ArrayList list = new ArrayList(int capacity) */

• JDK 8中 ArrayList 的變化：

ArrayList list = new ArrayList();// 底層Object[] elementData初始化為{}.并沒有創(chuàng)建長度為10的數(shù)組 list.add(123);// 第一次調(diào)用add()時，底層才創(chuàng)建了長度10的數(shù)組，并將數(shù)據(jù)123添加elementData[0] // 后續(xù)的添加和擴容操作與jdk 7 無異。

• JDK7 中的 ArrayList 的對象的創(chuàng)建類似于單例的餓漢式，而 JDK8 中的 ArrayList 的對象的創(chuàng)建類似于單例的懶漢式，延遲了數(shù)組的創(chuàng)建，節(jié)省內(nèi)存

4 List 的 remove() 方法

• 傳遞 int 類型則刪除對應(yīng)下標(biāo)的內(nèi)容，傳遞引用類型則刪除具體的實例

@Testpublic void testListRemove() {List list = new ArrayList();list.add(1);list.add(2);list.add(3);updateList(list);System.out.println(list);//}private void updateList(List list) {// remove 被重載，傳遞int類型則刪除對應(yīng)下標(biāo)的內(nèi)容，傳遞引用類型則刪除具體的實例list.remove(2); // 刪除下標(biāo)2list.remove(new Integer(2)); // 刪除 Integer 實例 2（下標(biāo)1）} }

5 ArrayList 的構(gòu)造方法與擴容機制*

參考鏈接

三種構(gòu)造方法：無參、傳入指定長度、傳入 Collection

// 屬性 private static final int DEFAULT_CAPACITY = 10; // 默認(rèn)的容量大小（常量） private static final Object[] EMPTY_ELEMENTDATA = {}; // 定義的空數(shù)組（final修飾，大小固定為0） private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 定義的默認(rèn)空容量的數(shù)組（final修飾，大小固定為0） transient Object[] elementData; // 定義的不可被序列化的數(shù)組，實際存儲元素的數(shù) private int size; // 數(shù)組中元素的個數(shù)// 無參的構(gòu)造方法 """ 容量此時是0，元素個數(shù)size為默認(rèn)值0 """ public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 只有調(diào)用無參構(gòu)造器才會獲得 DEFAULTCAPACITY_EMPTY_ELEMENTDATA }// 傳容量的構(gòu)造方法 """ initialCapacity > 0時，容量為initialCapacity，元素個數(shù)size為默認(rèn)值0 initialCapacity = 0時，容量為0，元素個數(shù)size為默認(rèn)值0 initialCapacity < 0時，拋出異常 """ public ArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA; // 調(diào)用有參構(gòu)造器傳入0，獲得EMPTY_ELEMENTDATA（區(qū)別于無參構(gòu)造器）} else {throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);} }// 傳入Collection元素列表的構(gòu)造方法 """ 如果傳入的Collection不包含元素，容量是0，元素個數(shù)size為0 如果傳入的Collection包含元素，容量為傳入序列的長度，元素個數(shù)size也為序列長度，此時的ArrayList是滿的 """ public ArrayList(Collection<? extends E> c) {// 將列表轉(zhuǎn)化為對應(yīng)的數(shù)組elementData = c.toArray();if ((size = elementData.length) != 0) {// 原對象數(shù)組的數(shù)組類型轉(zhuǎn)化為 Object對象數(shù)組的數(shù)組類型if (elementData.getClass() != Object[].class)elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 賦予空數(shù)組this.elementData = EMPTY_ELEMENTDATA;} }

擴容：add & grow

// 單參數(shù)的add方法，用戶使用的方法 public boolean add(E e) {modCount++;add(e, elementData, size);return true; }// 重載的多參數(shù)add方法 private void add(E e, Object[] elementData, int s) {// 判斷元素個數(shù)是否等于當(dāng)前容量，如果相等則調(diào)用無參的grow方法if (s == elementData.length)elementData = grow();elementData[s] = e;size = s + 1; }// 無參的grow方法 private Object[] grow() {return grow(size + 1); // 傳遞參數(shù)為需求的最小容量，也就是當(dāng)前容量+1 }// 重載的有參grow方法 """ if語句中不會處理 用默認(rèn) __無參構(gòu)造方法__ 創(chuàng)建的數(shù)組的 __初始擴容__ 情況，其余擴容情況都是由if語句處理ArraysSupport.newLength函數(shù)的作用是創(chuàng)建一個大小為oldCapacity + max(minimum growth， preferred growth)的數(shù)組 minCapacity是傳入的參數(shù)，上面顯示它的值是當(dāng)前容量+1，那么minCapacity - oldCapacity的值就恒為1，minimum growth的值也就恒為1 oldCapacity >> 1 右移一位，也就是減半，preferred growth的值即為oldCapacity大小的一半（當(dāng)oldCapacity為0時，右移后還是0） """ private Object[] grow(int minCapacity) {// 當(dāng)前容量int oldCapacity = elementData.length;// 如果當(dāng)前容量大于0 或者 數(shù)組不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA（創(chuàng)建時調(diào)用的是無參構(gòu)造器）if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {int newCapacity = ArraysSupport.newLength(oldCapacity,minCapacity - oldCapacity, /* 最小增長量 */oldCapacity >> 1 /* 傾向增長量 */);return elementData = Arrays.copyOf(elementData, newCapacity);// 如果 數(shù)組是DEFAULTCAPACITY_EMPTY_ELEMENTDATA（容量等于0的話，只剩這一種情況了）} else {return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];} }

• 容量增加 1 的情況：
  原來的容量為 0，而且是有參構(gòu)造器創(chuàng)建的 ArrayList（傳入 0 或者是空 Collection ，不能是無參構(gòu)造器創(chuàng)建）
• 容量變?yōu)樵瓉?.5倍的情況：
  原來的容量大于 0
• 容量變?yōu)?max(DEFAULT_CAPACITY, minCapacity) 的情況：
  原來的容量為 0，而且是無參構(gòu)造器創(chuàng)建的 ArrayList（其中 DEFAULT_CAPACITY = 10）
  也就是說，用默認(rèn)無參構(gòu)造方法創(chuàng)建的數(shù)組在添加元素前，ArrayList 的容量為0，添加一個元素后，ArrayList 的容量就變?yōu)?10

---

四 Collection 的子接口 Set

1 Comparable 與 Comparator

• Comparable 接口實際上是出自java.lang包，它有一個 compareTo(Object obj)方法用來排序 （類中蘊含的比較大小的方法）。

Collections.sort(arrayList); // arrayList中的元素重寫了compareTo(obj) // 重寫的規(guī)則是，如果當(dāng)前對象大于obj返回1，小于返回-1，等于返回0

• Comparator 接口實際上是出自 java.util 包，有一個 compare(Object obj1, Object obj2) 方法用來排序（比較器，用于比較兩個對象的大小）。

// 對于比較器，o1>o2返回1，o1=o2返回0，o1<o2返回-1 // 需要顯式傳入比較器 Collections.sort(arrayList, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);} });

2 Set 的無序性

• 無序性是指存儲的數(shù)據(jù)在底層數(shù)組中并非按照數(shù)組索引的順序添加 ，而是根據(jù)數(shù)據(jù)的哈希值決定的

3 HashSet、LinkedHashSet 和 TreeSet

• 都不是線程安全的
• HashSet 的底層數(shù)據(jù)結(jié)構(gòu)是哈希表（基于 HashMap 實現(xiàn)）；
• LinkedHashSet 的底層數(shù)據(jù)結(jié)構(gòu)是鏈表和哈希表（基于 LinkedHashMap 實現(xiàn)），元素的插入和取出順序滿足 FIFO；
• LinkedHashSet 是 HashSet 的子類，在添加數(shù)據(jù)的同時，每個數(shù)據(jù)還維護(hù)了兩個引用，記錄此數(shù)據(jù)前一個數(shù)據(jù)和后一個數(shù)據(jù)。優(yōu)點是對于頻繁的遍歷操作，LinkedHashSet 效率高于 HashSet
• TreeSet 底層數(shù)據(jù)結(jié)構(gòu)是紅黑樹，元素是有序的，排序的方式有自然排序和定制排序。自然排序中，比較兩個對象是否相同的標(biāo)準(zhǔn)為：compareTo() 返回0，而不再是equals()；定制排序中，比較兩個對象是否相同的標(biāo)準(zhǔn)為：compare() 返回0，而不再是equals()；所以不能放入無法排序的對象
• 因此，底層數(shù)據(jù)結(jié)構(gòu)不同又導(dǎo)致這三者的應(yīng)用場景不同。HashSet 用于不需要保證元素插入和取出順序的場景，LinkedHashSet 用于保證元素的插入和取出順序滿足 FIFO 的場景，TreeSet 用于支持對元素自定義排序規(guī)則的場景

// TreeSet的自定排序（TreeMap同理）public void test2(){Comparator com = 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 Integer.compare(u1.getAge(),u2.getAge());}else{throw new RuntimeException("輸入的數(shù)據(jù)類型不匹配");}}};TreeSet set = new TreeSet(com);}

4 HashSet 加入實例時，查重的方式（類似實例間的相等比較）**

• 當(dāng)對象加入HashSet 時，HashSet 會先計算對象的 hashcode值來判斷對象加入的位置
• 如果該位置無對象，則 HashSet 中無重復(fù)元素，加入成功
• 如果該位置有對象（下標(biāo)相同的兩個對象， hashcode不一定相同），與相同位置的其他的對象的 hashcode 值作比較，如果沒有相符的 hashcode，則無重復(fù)元素，加入成功
• 但是如果發(fā)現(xiàn)有相同 hashcode 值的對象，這時會調(diào)用 equals() 方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓加入操作成功

5 HashSet 存儲原理的實例**

典中典

public void test3(){HashSet set = new HashSet();Person p1 = new Person(1001,"AA");Person p2 = new Person(1002,"BB");set.add(p1);set.add(p2);System.out.println(set);p1.name = "CC";set.remove(p1);System.out.println(set); // BB, CCset.add(new Person(1001,"CC"));System.out.println(set); // BB, CC, CCset.add(new Person(1001,"AA"));System.out.println(set); // BB, CC, CC, AA}

---

五 Collection 的子接口 Queue

1 Queue 與 Deque

• Queue 是單端隊列，只能從一端插入元素，另一端刪除元素，實現(xiàn)上一般遵循 FIFO 規(guī)則

• Queue 的兩套方法：
  

• Deque 是雙端隊列，在隊列的兩端均可以插入或刪除元素

• Deque 的兩套方法：
  

2 PriorityQueue

• PriorityQueue 利用了二叉堆的數(shù)據(jù)結(jié)構(gòu)來實現(xiàn)的，底層使用可變長的數(shù)組來存儲數(shù)據(jù)
• PriorityQueue 通過堆元素的上浮和下沉，實現(xiàn)了在 O(logn) 的時間復(fù)雜度內(nèi)插入元素和刪除堆頂元素。
• PriorityQueue 是非線程安全的，且不支持存儲 NULL 和 non-comparable 的對象（因為無法比較就無法排序）
• PriorityQueue 默認(rèn)是小頂堆，但可以接收一個 Comparator 作為構(gòu)造參數(shù)，從而來自定義元素優(yōu)先級的先后

3 ArrayDeque 與 LinkedList

• ArrayDeque 和 LinkedList 都實現(xiàn)了 Deque 接口，兩者都具有隊列的功能
• ArrayDeque 是基于可變長的數(shù)組和雙指針來實現(xiàn)，而 LinkedList 則通過鏈表來實現(xiàn)
• ArrayDeque 插入時可能存在擴容過程, 不過均攤后的插入操作依然為 O(1)。雖然 LinkedList 不需要擴容，但是每次插入數(shù)據(jù)時均需要申請新的堆空間，均攤性能相比更慢。從性能的角度上，選用 ArrayDeque 來實現(xiàn)隊列要比 LinkedList 更好

---

六 Collection 的子接口 Map

1 HashMap 和 Hashtable

• Hashtable 基本被淘汰，不要在代碼中使用它
• HashMap 是非線程安全的，Hashtable 是線程安全的，因為 Hashtable 內(nèi)部的方法基本都經(jīng)過 synchronized 修飾
• HashMap 可以存儲 null 的 key 和 value，但 null 作為鍵只能有一個，null 作為值可以有多個；Hashtable 不允許有 null 鍵和 null 值，否則會拋出 NullPointerException
• 都采用數(shù)組+鏈表的形式。HashMap 在解決哈希沖突時有了較大的變化，當(dāng)鏈表長度大于閾值（默認(rèn)為 8）（將鏈表轉(zhuǎn)換成紅黑樹前會判斷，如果當(dāng)前數(shù)組的長度小于 64，那么會選擇先進(jìn)行數(shù)組擴容，而不是轉(zhuǎn)換為紅黑樹）時，將鏈表轉(zhuǎn)化為紅黑樹，以減少搜索時間。Hashtable 沒有這樣的機制
• HashMap 總是使用 2 的冪作為哈希表的大小。創(chuàng)建時如果給定了容量初始值，那么 Hashtable 會直接使用給定的大小，而 HashMap 會將其擴充為 2 的冪次方大小

2 HashMap 和 HashSet

• HashSet 是基于 HashMap 實現(xiàn)的。
  

3 HashMap 的長度為什么是 2 的冪次方

• 為了能讓 HashMap 存取高效，盡量較少碰撞，也就是要盡量把數(shù)據(jù)分配均勻。Hash 值的范圍值-2147483648 到 2147483647，前后加起來大概 40 億的映射空間，只要哈希函數(shù)映射得比較均勻松散，一般應(yīng)用是很難出現(xiàn)碰撞的。但問題是一個 40 億長度的數(shù)組，內(nèi)存是放不下的。所以這個散列值是不能直接拿來用的。用之前還要先做對數(shù)組的長度取模運算，得到的余數(shù)才能用來要存放的位置也就是對應(yīng)的數(shù)組下標(biāo)。這個數(shù)組下標(biāo)的計算方法是“ (n - 1) & hash”（n 代表數(shù)組長度）

• hash%length == hash&(length-1)的前提是 length 是 2 的 n 次方。所以要求 HashMap 的長度是 2 的冪次方

4 ConcurrentHashMap 和 Hashtable

• 均線程安全
• 數(shù)據(jù)結(jié)構(gòu)：

類型數(shù)據(jù)結(jié)構(gòu)使用的鎖

ConcurrentHashMap JDK1.7	Segment 數(shù)組 + HashEntry 數(shù)組 + 鏈表/紅黑樹	Segment（本質(zhì)是 ReentrantLock），每次鎖若干 HashEntry
ConcurrentHashMap JDK1.8	Node 數(shù)組 + 鏈表/紅黑樹	synchronized，每次鎖一個 Node
Hashtable	數(shù)組+鏈表	synchronized，每次鎖全表

在 JDK1.7 的時候，ConcurrentHashMap 采用分段鎖機制，對整個桶數(shù)組進(jìn)行了分割分段（Segment，每個 Segment 都是一個可重入鎖），每一個 Segment 只鎖容器其中一部分?jǐn)?shù)據(jù)，多線程訪問容器里不同數(shù)據(jù)段的數(shù)據(jù)不會存在鎖競爭，提高并發(fā)訪問率

static class Segment<K,V> extends ReentrantLock implements Serializable { }

JDK1.8 的時候已經(jīng)摒棄了 Segment 的概念，synchronized 只鎖定當(dāng)前鏈表或紅黑二叉樹的首節(jié)點，并發(fā)控制使用 synchronized 和 CAS 來操作，雖然在 JDK1.8 中還能看到 Segment 的數(shù)據(jù)結(jié)構(gòu)，但是已經(jīng)簡化了屬性，只是為了兼容舊版本

Hashtable(同一把鎖) ：使用 synchronized 來保證線程安全，效率非常低下。當(dāng)一個線程訪問同步方法時，其他線程也訪問同步方法，可能會進(jìn)入阻塞或輪詢狀態(tài)，如使用 put 添加元素，另一個線程不能使用 put 添加元素，也不能使用 get，競爭會越來越激烈效率越低

5 CAS (Compare And Swap)

V：要更新的變量(var)
E：預(yù)期值(expected)
N：新值(new)

• 比較并交換的過程：判斷V是否等于E，如果等于，將V的值設(shè)置為N；如果不等，說明已經(jīng)有其它線程更新了V，則當(dāng)前線程放棄更新，什么都不做
• 當(dāng)多個線程同時使用CAS操作一個變量時，只有一個會勝出，并成功更新，其余均會失敗，但失敗的線程并不會被掛起，僅是被告知失敗，并且允許再次嘗試，當(dāng)然也允許失敗的線程放棄操作

6 HashMap 的底層實現(xiàn)

• 和 HashSet 相同，因為 HashSet 是基于 HashMap 實現(xiàn)的
• 以JDK7為例說明：

HashMap map = new HashMap() //在實例化以后，底層創(chuàng)建了長度是*16*的一維數(shù)組 Entry[] table map.put(key1,value1):

• 首先，調(diào)用key1所在類的 hashCode() 計算key1哈希值，此哈希值經(jīng)過某種算法計算以后，得到在Entry數(shù)組中的存放位置。如果此位置上的數(shù)據(jù)為空，此時的 key1-value1 添加成功。
• 如果此位置上的數(shù)據(jù)不為空，(意味著此位置上存在一個或多個數(shù)據(jù)(以鏈表形式存在))，比較key1和已經(jīng)存在的一個或多個數(shù)據(jù)的哈希值：如果key1的哈希值與已經(jīng)存在的數(shù)據(jù)的哈希值都不相同，此時 key1-value1 添加成功。
• 如果key1的哈希值和已經(jīng)存在的某一個數(shù)據(jù) key2-value2 的哈希值相同，繼續(xù)比較：調(diào)用 key1 所在類的 equals(key2) 方法，比較：
  如果 equals() 返回false：此時 key1-value1 添加成功
  如果 equals() 返回true：使用 value1 替換 value2

JDK8 相較于 JDK7 在底層實現(xiàn)方面的不同：

• new HashMap()：底層沒有創(chuàng)建一個長度為16的數(shù)組（懶漢式），首次調(diào)用 put() 方法時，底層創(chuàng)建長度為16的數(shù)組
• JDK8 底層的數(shù)組是：Node[]（因為支持了鏈表轉(zhuǎn)紅黑樹），而非 HashEntry[]
• JDK7 底層結(jié)構(gòu)是 HashEntry 數(shù)組+鏈表；JDK8 中底層結(jié)構(gòu)：Node 數(shù)組 + 鏈表 / 紅黑樹。當(dāng)數(shù)組的某一個索引位置上的元素以鏈表形式存在的數(shù)據(jù)個數(shù) > 8 且當(dāng)前數(shù)組的長度 > 64時，此時此索引位置上的所數(shù)據(jù)改為使用紅黑樹存儲

7 HashMap 底層實現(xiàn)的參數(shù)

• DEFAULT_INITIAL_CAPACITY : HashMap的默認(rèn)容量，16
• DEFAULT_LOAD_FACTOR：HashMap的默認(rèn)裝載因子：0.75，是對空間和時間效率的一個平衡選擇
• threshold：擴容的臨界值，數(shù)值上等于 容量*填充因子：16 * 0.75 => 12
• TREEIFY_THRESHOLD：Bucket中鏈表長度大于該默認(rèn)值，轉(zhuǎn)化為紅黑樹，默認(rèn)8
• MIN_TREEIFY_CAPACITY：桶中的Node被樹化時最小的hash表容量，默認(rèn)64

8 JDK 8 HashMap 的擴容

• HashMap 在創(chuàng)建時不創(chuàng)建 Node 數(shù)組，而在首次添加 (k, v) 時申請長度為 16 的數(shù)組
• HashMap 的數(shù)組長度一定是 2 的冪次，目的是方便計算哈希值對數(shù)組長度取模
• HashMap 只有在插入元素時才會初始化（創(chuàng)建 Node 數(shù)組），或者擴容；具體地，擴容還要滿足兩個條件之一：
• 當(dāng)前存入數(shù)據(jù)大于閾值
• 存入數(shù)據(jù)到某一條鏈表時，該鏈表數(shù)據(jù)個數(shù)大于 8，且數(shù)組長度小于 64
• 擴容的具體操作：
• 將 Node 數(shù)組長度變?yōu)樵瓉淼?2 倍
• 調(diào)整原數(shù)據(jù)在新數(shù)組中的索引，調(diào)用 resize 方法，根據(jù)原來的 hash 值新增的 bit 是0還是1，0=索引不變，1=原來的索引 + 原來哈希表的長度

---

七 Iterator

1 Iterator的使用方法

public class IteratorTest {@Testpublic void test1(){Collection coll = new ArrayList();coll.add(123);coll.add(456);Iterator iterator = coll.iterator();while(iterator.hasNext()){//next():①指針下移 ②將下移以后集合位置上的元素返回System.out.println(iterator.next());}

2 遍歷中刪除元素

• 只能使用 Iterator
• 如果還未調(diào)用 next() 或在上一次調(diào)用 next() 方法之后已經(jīng)調(diào)用了 remove() 方法，再調(diào)用 iterator.remove() 都會 IllegalStateException
• iterator 調(diào)用的 remove() ，和集合對象的 remove() 不同

//刪除集合中"Tom"Iterator iterator = coll.iterator();while (iterator.hasNext()){Object obj = iterator.next();if("Tom".equals(obj)){iterator.remove();}}

---

八 Collections 工具類的常用靜態(tài)方法

• reverse(List)：反轉(zhuǎn) List 中元素的順序
• shuffle(List)：對 List 集合元素進(jìn)行隨機排序
• sort(List)：根據(jù)元素的自然順序?qū)χ付?List 集合元素按升序排序
• sort(List，Comparator)：根據(jù)指定的 Comparator 產(chǎn)生的順序?qū)?List 集合元素進(jìn)行排序
• swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進(jìn)行交換
• Object max(Collection)：根據(jù)元素的自然順序，返回給定集合中的最大元素
• Object max(Collection，Comparator)：根據(jù) Comparator 指定的順序，返回給定集合中的最大元素
• int frequency(Collection，Object)：返回指定集合中指定元素的出現(xiàn)次數(shù)
• void copy(List dest,List src)：將src中的內(nèi)容復(fù)制到dest中
• boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替換 List 對象的所有舊值

總結(jié)

以上是生活随笔為你收集整理的后端学习 - Java容器的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。