思考
1、假如我們要創建已知長度的集合List（ArrayList）or Map（HashMap），如何創建？
通常
Map<Integer,Object> map = new HashMap<>(1);
List<String> list = new ArrayList<>(1);
固定長度，減少擴容次數
2、HashMap構造函數，除了初始化容量，還有其它參數嗎？
還有個擴容因子loadFactor
印象中以為ArrayList和HashMap都有loadFactor，其實只有HashMap中有，ArrayList中沒有。那么他們是如何實現擴容的呢？
ArrayList
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
add()方法調用ensureCapacityInternal()方法。size表示元素數量，同list.size()方法
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 code
// 是否擴容判斷
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
最小容量 (minCapacity) = size + 1；
當最小容量大于存儲數組長度時，觸發擴容，so...數組存儲滿時再添加新元素觸發擴容。
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int 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);
}
新容量(newCapacity) = 原容量 + 原容量位運算左移1位
最后通過Arrays.copyOf方法完成復制擴容。
注：左移1位 = n／2 取整
總結：
1、擴容觸發點，數組存儲已滿，再add()時觸發
2、擴容量，大概是原來的一半，準確是 newCapacity = oldCapacity + (oldCapacity >> 1);
HashMap
錯誤理解，原印象擴容因子loadFactor，默認0.75，即假如當前容量是100時，元素數量達到75，即75%時觸發擴容。擴容量是當前容量值最近2n次方。
正解：
hashMap.put(key,value)會調用resize()方法
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
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;//此處1
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//此處省略...
}
++modCount;
if (++size > threshold)
resize();//此處2
afterNodeInsertion(evict);
return null;
}
此處1：第一次put時初始化table，調用resize()方法
此處2：新增后元素數量大于threshold，調用resize()方法
threshold閾值,注釋【The next size value at which to resize (capacity * load factor)】
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//此處1
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//此處2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//此處3
else if (oldThr > 0) //initial capacity was placed in threshold
newCap = oldThr;
//此處4
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//此處5
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
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];
table = newTab;
//中間省略...
}
新閾值和新容量計算稍復雜，仔細梳理每行代碼，拋開容量最大值、超出int范圍問題，代碼解讀
新閥值：
1、當原容量大于0 && 原容量右移1位后小于最大容量 && 原容量大于初始容量，新閾值等于原閾值右移1位，即新閾值 = 原閾值2
2、當原容量等于0 && 原閾值等于0，新閥值等于默認擴容因子（0.75） 默認初始化容量（16）
3、前兩種都不滿足時，新容量 * 擴容因子
新容量：
4、當原容量大于0，新容量等于原右移1位
5、當原容量等于0 && 原閾值大于0，新容量等于原閾值
6、當原容量等于0 && 原閾值等于0，新容量等于默認初始容量
場景：
1、new HashMap()，第一次put，原容量等于0，原閾值等于0，執行代碼"此處4"
2、new HashMap()，第n（1< n <int最大值）次put時，原容量大于0，原閾值大于默認初始容量，執行代碼"此處2"
3、new HashMap(initialCapacity)，第一次put時，因設置初始容量，閥值會在構造函數初始化，閥值等于 比initialCapacity大于等于的最近2的n次方(假如設置初始容量3，比3大的最近的2的n次方是4)，所以原容量等于0，原閾值大于0，執行代碼"此處3"，新閾值等于0 , 代碼"此處5"也會執行。
4、new HashMap(initialCapacity)，如果table已有元素，那么原容量大于0，當原容量小于默認容量時，只會執行代碼"此處5"
5、new HashMap(initialCapacity)，如果table已有元素，同上，原容量大于0，當原容量大于等于默認容量時，只會執行代碼"此處2"
總結
1、只原容量等于0或原容量小于默認初始容量時，新閥值 = 新容量 * 擴容因子
2、非1情況，新閥值 = 新容量 = 原容量*2
Redis列表和數組擴容機制類似，后續補充。。。
如有錯誤歡迎指正，謝謝～
下篇準備寫ThreadPool。
