一、集合框架圖

Java集合框架主要包含兩種類型的容器，一是集合(Collection)，存儲元素集合，二是圖(Map)，存儲鍵(key)-值(value)對.Collection接口下面有兩個重要的子接口List和Set，再下面是一些抽象類，最后是實現類，常用的實現類有HashSet、ArrayList、HashMap等等。

二、Set和List的區別

Set接口實例存儲的是一組唯一，無序的對象。List實例存儲的是一組不唯一，有序的對象。

Set遍歷效率低，刪除和插入效率高，刪除和插入不會引起對象位置改變。

List遍歷效率高，刪除和插入效率低，因為刪除和插入會引起對象位置改變。

三、集合實現類

1、ArrayList

繼承AbstractList，實現了List接口。底層基于數組實現容量動態變化，允許元素為null，下面我們來看JDK1.8版本的ArrayList源碼。

重要屬性

private static final int DEFAULT_CAPACITY = 10;private static final Object[] EMPTY_ELEMENTDATA = {};private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};transient Object[] elementData;private int size;

DEFAULT_CAPACITY：默認容量大小

EMPTY_ELEMENTDATA ：空數組

DEFAULTCAPACITY_EMPTY_ELEMENTDATA ：默認容量的空數組

elementData：ArrayList的內部結構，是一個Object[]類型的數組

size：ArrayList包含的元素的數量

構造方法

public ArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}public ArrayList(Collection<? extends E> c) {elementData = c.toArray();if ((size = elementData.length) != 0) {if (elementData.getClass() != Object[].class)elementData = Arrays.copyOf(elementData, size, Object[].class);} else {this.elementData = EMPTY_ELEMENTDATA;}}

ArrayList(int initialCapacity)：實例化ArrayList對象時指定容量大小。

ArrayList()：無參構造方法，通過此構造器創建的ArrayList,第一次使用add方法添加元素時,容量為10。

ArrayList(Collection<? extends E> c)：接收一個Collection的實例，將該實例轉化成ArrayList對象。

add(E e)方法

先看add(E e)方法相關的源碼：

public boolean add(E e) {ensureCapacityInternal(size + 1); // Increments modCount!!elementData[size++] = e;return true;}private void ensureCapacityInternal(int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}ensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) {modCount++;// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity);}private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1);if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);}

我們可以看到add(E e)方法首先會調用ensureCapacityInternal方法來檢查容量大小，如果發現elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，即ArrayList通過無參構造器來實例化并且是第一次調用add方法，那么會將容量大小設置為默認容量大小10。

ensureExplicitCapacity方法判斷如果所需的最小容量大于數組當前長度，那么需要擴容

grow方法來進行實際的擴容操作，新的數組長度是原來的3/2倍，并且新數組長度不能大于Integer.MAX_VALUE - 8，然后使用Arrays.copyOf方法將原來的數據復制到新數組中

使用ArrayList遇到的坑

如下代碼中，在遍歷List時，調用了remove方法，刪除元素a

//arrayList中的值為 [a,a,c,a,a] for (int i = 0; i < arrayList.size(); i++) {if (arrayList.get(i) == "a") {arrayList.remove(i);} } System.out.println(arrayList);

這段代碼看似解決了刪除列表中所有的a元素，但是刪除后得出List的結果為[a, c, a]，為什么這種方式沒有達到想要的效果，其實仔細分析后會發現，在調用remove()方法時List的長度會發生變化而且元素的位置會發生移動，從而在遍歷時list實際上是變化的，例如

當i=0時，此時list中的元素為[a,a,c,a,a],

• 但當i=1時，此時List中的元素為[a,c,a,a],元素的位置發生了移動，從而導致在遍歷的過程中不能達到刪除的效果

解決方案

逆向遍歷

使用迭代器遍歷（推薦用此方法）

Iterator<String> ite = arrayList.listIterator(); while (ite.hasNext()){if(ite.next() == "a")ite.remove(); } System.out.println(arrayList);

其他注意點

ArryList進行擴容時，需要將原有數組的元素拷貝到一個新數組中，非常耗時，所以建議在確定ArrayList元素數量的時候再使用它。

2、HashMap

繼承AbstractMap，是基于哈希表的Map接口的非同步實現，存儲的對象是Node（包含key和value），key和value都可以為null，最多存在一個鍵值對的key為null。不保證有序（比如插入順序），并且不保證順序不隨時間發生變化。

JDK1.7以前由數組+鏈表組成，JDK1.8由數組+鏈表+紅黑樹組成，使用鏈表是為了解決哈希沖突（兩個對象的hashCode方法計算的哈希碼值一致導致計算出的數組下標相同），當鏈表長度大于閾值（默認8）并且當前數組長度大于64時，此時此下標位置上的所有元素使用紅黑樹存儲，注意如果僅僅是某個鏈表長度大于閾值，選擇進行擴容。

底層數據結構：

1,new HashMap<>()

jdk1.7之前，創建了一個長度16的Entry數組，jdk1.8是在首次調用put方法時，創建一個長度16的Node數組。

2.put方法

對key做hash操作（先調用key的hashCode方法得到哈希碼值，然后哈希碼值跟它無符號右移16位的值做異或運算），再調用putVal方法

先判斷Node數組是否為null或者長度等于0，如果是那么resize方法進行擴容

hash操作得到的值與數組長度-1做與運算得到數組下標

得到下標后，判斷數組當前位置是否有元素，如果沒有，將鍵值對放到數組當前位置

如果已有元素，那么調用新key的equals方法跟原有key進行比較，如果相同替換原有value，如果不相同將新的鍵值對放到鏈表的末尾或者放到紅黑樹中

上面流程完成后，如果size>threshold,那么調用resize方法擴容

3.resize方法

由于每次擴容都是翻倍，與原來的n-1&hash相比，只是多了一個二進制位，所以節點要么是原來位置，要么是原來位置+原容量這個位置。因此只需要判斷原來的hash值新增的bit位是1還是0

問題：

1，為什么HashMap的容量是2的冪次方？容量是2的冪次方有什么好處？如果創建HashMap對象時實參不是2的冪次方會怎么樣？

jdk1.8putVal方法計算數組下標的時候使用(數組長度 - 1) & hash，數組長度是2的冪次方的時候這個表達式的結果與hash%數組長度相同，并且能夠讓數據均勻分布減少哈希碰撞

tableSizeFor方法會計算出一個大于且最接近的2的冪次方數，通過一系列的無符號右移運算和與運算得出（思想是將這個數的最高位下面的bit位全部變成1，第一次運算保證最高位至少有兩個連續的1，第二次運算保證最高位至少有四個連續的1。。。，最后一次運算保證最高位有十六個連續的1）

2.loadFactor負載因子為什么是0.75

當size>capacity*loadFactor時哈希表會擴容，如果太大會導致查詢效率低，過小會導致數組的利用率低，存放的數據會很分散。0.75是官方經過大量測試得出的最優的結果。

JDK1.8HashMap的源碼

重要屬性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默認的初始化容量16，HashMap容器的容量必須是2的次方static final int MAXIMUM_CAPACITY = 1 << 30;//最大的容量static final float DEFAULT_LOAD_FACTOR = 0.75f;//默認的負載因子，構造函數沒有指定時使用static final int TREEIFY_THRESHOLD = 8;//樹化的閾值，哈希桶元素的數量至少為8時才會轉化成紅黑樹static final int UNTREEIFY_THRESHOLD = 6;//鏈表化的閾值，當進行resize操作時，哈希桶元素的數量不超過6時才會轉化成鏈表static final int MIN_TREEIFY_CAPACITY = 64;//樹化最小容量，容量至少為64時才會轉化成紅黑樹transient Node<K,V>[] table;//HashMap容器實現存儲功能的數組，必須是2的次方transient Set<Map.Entry<K,V>> entrySet;//保存緩存的entrySettransient int size;//HashMap容器包含的鍵值對數量transient int modCount;//HashMap結構被修改的次數（是指鍵值對數量改變或者rehash）int threshold;//進行resize操作的大小，=當前最大容量*負載因子final float loadFactor;//負載因子

重要的內部類

Node:基本的哈希桶節點

static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;V value;Node<K,V> next;Node(int hash, K key, V value, Node<K,V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;}public final K getKey() { return key; }public final V getValue() { return value; }public final String toString() { return key + "=" + value; }public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);}public final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}public final boolean equals(Object o) {if (o == this)return true;if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;if (Objects.equals(key, e.getKey()) &&Objects.equals(value, e.getValue()))return true;}return false;}}

TreeNode：繼承LinkedHashMap的內部類Entry，而LinkedHashMap.Entry又繼承Node，所以TreeNode算是Node的孫子類

TreeNode的方法太多，這里只貼出它的屬性

TreeNode<K,V> parent; // red-black tree linksTreeNode<K,V> left;TreeNode<K,V> right;TreeNode<K,V> prev; // needed to unlink next upon deletionboolean red;

重要方法

static final int tableSizeFor(int cap) {int n = cap - 1;n |= n >>> 1;n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;}//計算hashstatic final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//先計算hashCode,然后將得到的值與它的高16位做異或運算，得到hash}public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)//計算index，數組長度減一并與hash做與運算tab[i] = newNode(hash, key, value, null);else {Node<K,V> e; K k;if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;else if (p instanceof TreeNode)e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) //如果鏈表的長度大于等于樹化閾值8，將鏈表轉換成紅黑樹treeifyBin(tab, hash);break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;}//此方法只是將鏈表轉換成雙向鏈表，真正樹化操作在treeify方法final void treeifyBin(Node<K,V>[] tab, int hash) {int n, index; Node<K,V> e;if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode<K,V> hd = null, tl = null;do {TreeNode<K,V> p = replacementTreeNode(e, null);if (tl == null)hd = p;else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);if ((tab[index] = hd) != null)hd.treeify(tab);}}//將雙向鏈表轉換成平衡二叉查找樹final void treeify(Node<K,V>[] tab) {TreeNode<K,V> root = null;for (TreeNode<K,V> x = this, next; x != null; x = next) {next = (TreeNode<K,V>)x.next;x.left = x.right = null;if (root == null) {x.parent = null;x.red = false;root = x;}else {K k = x.key;int h = x.hash;Class<?> kc = null;for (TreeNode<K,V> p = root;;) {int dir, ph;K pk = p.key;if ((ph = p.hash) > h)dir = -1;else if (ph < h)dir = 1;else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0)dir = tieBreakOrder(k, pk);TreeNode<K,V> xp = p;if ((p = (dir <= 0) ? p.left : p.right) == null) {x.parent = xp;if (dir <= 0)xp.left = x;elsexp.right = x;root = balanceInsertion(root, x);break;}}}}moveRootToFront(tab, root);}final Node<K,V>[] resize() {//把沒插入之前的哈希數組做我誒oldTalNode<K,V>[] oldTab = table;//old的長度int oldCap = (oldTab == null) ? 0 : oldTab.length;//old的臨界值int oldThr = threshold;//初始化new的長度和臨界值int newCap, newThr = 0;//oldCap > 0也就是說不是首次初始化，因為hashMap用的是懶加載if (oldCap > 0) {//大于最大值if (oldCap >= MAXIMUM_CAPACITY) {//臨界值為整數的最大值threshold = Integer.MAX_VALUE;return oldTab;}//標記##，其它情況，擴容兩倍，并且擴容后的長度要小于最大值，old長度也要大于16else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)//臨界值也擴容為old的臨界值2倍newThr = oldThr << 1; }/**如果oldCap<0，但是已經初始化了，像把元素刪除完之后的情況，那么它的臨界值肯定還存在， 如果是首次初始化，它的臨界值則為0**/else if (oldThr > 0) newCap = oldThr;//首次初始化，給與默認的值else { newCap = DEFAULT_INITIAL_CAPACITY;//臨界值等于容量*加載因子newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}//此處的if為上面標記##的補充，也就是初始化時容量小于默認值16的，此時newThr沒有賦值if (newThr == 0) {//new的臨界值float ft = (float)newCap * loadFactor;//判斷是否new容量是否大于最大值，臨界值是否大于最大值newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);}//把上面各種情況分析出的臨界值，在此處真正進行改變，也就是容量和臨界值都改變了。threshold = newThr;//表示忽略該警告@SuppressWarnings({"rawtypes","unchecked"})//初始化Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//賦予當前的tabletable = newTab;//此處自然是把old中的元素，遍歷到new中if (oldTab != null) {for (int j = 0; j < oldCap; ++j) {//臨時變量Node<K,V> e;//當前哈希桶的位置值不為null，也就是數組下標處有值，因為有值表示可能會發生沖突if ((e = oldTab[j]) != null) {//把已經賦值之后的變量置位null，當然是為了好回收，釋放內存oldTab[j] = null;//如果下標處的節點沒有下一個元素if (e.next == null)//把該變量的值存入newCap中，e.hash & (newCap - 1)并不等于jnewTab[e.hash & (newCap - 1)] = e;//該節點為紅黑樹結構，也就是存在哈希沖突，該哈希桶中有多個元素else if (e instanceof TreeNode)//把此樹進行轉移到newCap中((TreeNode<K,V>)e).split(this, newTab, j, oldCap);else { /**此處表示為鏈表結構，同樣把鏈表轉移到newCap中，就是把鏈表遍歷后，把值轉過去，在置位null**/Node<K,V> loHead = null, loTail = null;Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;do {next = e.next;if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);if (loTail != null) {loTail.next = null;newTab[j] = loHead;}if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}//返回擴容后的hashMapreturn newTab;}

關于更詳細的HashMap紅黑樹知識，請參考【Java入門提高篇】Day25 史上最詳細的HashMap紅黑樹解析 - 弗蘭克的貓 - 博客園

遍歷HashMap

Map<String,String> map = new HashMap<String,String>();map.put("郭如飛", "yz");map.put("余豪", "lazy");for (Entry<String, String> entry : map.entrySet()){System.out.println("鍵："+entry.getKey()+"，值："+entry.getValue());}

3、HashSet

HashSet繼承AbstractSet，實現Set接口，內部存儲是HashMap。當HashSet中存儲元素時，直接將這個元素作為key,默認的Object常量作為value，存儲在map中。

4、LinkedList

LinkedList繼承了AbstractSequentialList，實現了List和Deque接口。本質上是一個雙向鏈表。

由于實現了Deque接口，可以將LinkedList當做一個隊列，去處理其中的元素。

AbstractSequentialList類實現連續訪問數據（鏈表）所需的工作，如果是隨機訪問（數組）建議用AbstractList，而不是AbstractSequentialList

重要屬性

transient int size = 0;//集合大小transient Node<E> first;//指向頭結點transient Node<E> last;//指向尾結點

構造方法

public LinkedList() {}public LinkedList(Collection<? extends E> c) {this();addAll(c);}

內部類

Node用來表示LinkedList集合的元素

private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}

重要方法

add(E e)

public boolean add(E e) {linkLast(e);return true;}void linkLast(E e) {final Node<E> l = last;final Node<E> newNode = new Node<>(l, e, null);//創建一個Nodelast = newNode;//尾結點指向當前元素if (l == null)first = newNode;//如果last==null說明鏈表沒有任何元素，此時添加的元素即為頭結點elsel.next = newNode;//將鏈表的最后一個元素指向新的元素size++;modCount++;}

remove(Object o)、remove(int index)

public boolean remove(Object o) {if (o == null) {for (Node<E> x = first; x != null; x = x.next) {if (x.item == null) {unlink(x);return true;}}} else {for (Node<E> x = first; x != null; x = x.next) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}public E remove(int index) {checkElementIndex(index);return unlink(node(index));}E unlink(Node<E> x) {// assert x != null;final E element = x.item;final Node<E> next = x.next;final Node<E> prev = x.prev;if (prev == null) {first = next;} else {prev.next = next;x.prev = null;}if (next == null) {last = prev;} else {next.prev = prev;x.next = null;}x.item = null;size--;modCount++;return element;}Node<E> node(int index) {// assert isElementIndex(index);if (index < (size >> 1)) {Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else {Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;}}

5、Vector

繼承了AbstractList，實現了List接口，是一個線程安全的動態數組。

同ArrayList相比，除了線程安全（很多方法加了synchronized）外，其他地方基本一致。

6、Stack

繼承了Vector，基于動態數組實現的一個線程安全的棧

7、Hashtable和HashMap的區別

1、 hashmap中key和value均可以為null，但是hashtable中key和value均不能為null。

2、 hashmap采用的是數組(桶位)+鏈表+紅黑樹結構實現（jdk1.8之后），而hashtable中采用的是數組(桶位)+鏈表實現。

3、 hashmap中出現hash沖突時，如果鏈表節點數小于8時是將新元素加入到鏈表的末尾，而hashtable中出現hash沖突時采用的是將新元素加入到鏈表的開頭。

4、 hashmap中數組容量的大小要求是2的n次方，如果初始化時不符合要求會進行調整，必須為2的n次方，而hashtable中數組容量的大小可以為任意正整數。

5、 hashmap中的尋址方法采用的是位運算按位與,而hashtable中尋址方式采用的是求余數。

6、 hashmap不是線程安全的，而hashtable是線程安全的，hashtable中的get和put方法均采用了synchronized關鍵字進行了方法同步。

7、 hashmap中默認容量的大小是16，而hashtable中默認數組容量是11。

8、集合類中常用的方法

Java集合框架的實現源碼，經常看到 Arrays.copy()、System.arraycopy() 方法，以下稍作整理。

Arrays.copyOf()?

作用：基于原數組復制一個新的數組并返回，不影響原有數組

我們這里看到copyOf方法有很多重載的方法，這里我只看public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)，因為其他方法同這個方法類似。

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {@SuppressWarnings("unchecked")T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}

從源碼可以看出來，copyOf方法是通過System.arraycopy方法來復制數組的。下面我們看一下

System.arraycopy

public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

src:源數組

srcPos:源數組開始復制的索引

dest:目標數組

destPos:目標數組開始復制的索引

length:復制的長度

注意：System.arraycopy是淺復制，如果數組元素的類型是引用類型，復制的是引用類型對象的地址值，不是真的將原有對象復制一份。

Object[] toArray();<T> T[] toArray(T[] a);

Collection接口定義的兩個抽象方法，集合實現類必須實現的兩個方法，將集合轉換成數組，區別是后者泛型方法。

9、Iterator迭代器實現原理

Java中Iterator(迭代器)實現原理 - wss96 - 博客園 (cnblogs.com)

總結

以上是生活随笔為你收集整理的【JAVA基础篇】集合框架的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。