集合原始碼分析
阿新 • • 發佈：2020-07-22
Collection
代表一組物件,JDK不提供該介面的直接實現類,它提供了兩個特定的子介面:Set和List。
List
是有序的集合,使用者可以通過索引訪問元素。List允許重複值。素引從0開始。
List介面提供了一個特殊的送代器,允許元素的插入和替換,以及除了其他選代器介面的常規操作的雙向訪問。
ArrayList
每個ArrayList例項都有一個容量,是儲存的元素的陣列的大小。向Arraytist新增元素時,容量會自動增長。
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
基於可變長度陣列的實現。可以存入任何值,包含null。
向指定索引新增元素時,會將當前陣列自當前索引後的所有物件複製到索引加一的位置,將新元素放入到當前位置。
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
新增大量元素時會呼叫ensureCapacity操作增加ArrayList的容量,可以減少重新分配的數量。
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);
}
該方法是非同步的。
Vector
Vector實現了一個可增長的物件陣列。可以通過索引訪問元素。
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
每個Vector嘗試維護capacity和capacityIncrement來優化儲存。當大量元素新增到Vector時，陣列會以capacityIncrement的大小進行擴容。
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
與Array list不同,Vector是同步的。
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
Linkedlist
Linkedlist是List和Deque的一種雙向連結串列的實現方式。可以存入任何值,包含null。
操作索引會從接近指定的索引位置的頭部或尾部遍歷列表。
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;
}
}
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;
}
}
該實現是非同步的。
防止對List的非同步的訪問，在建立時最好同步化。
List list = Collections.synchronizedList(new LinkedList(...));
Set
不包含重複資料的集合。可以為null,但只能有一個 。
HashSet
底層通過hashmap實現。不保證元素的順序（指插入順序，基於hash值排序）,可為null。
private transient HashMap<E,Object> map;
public HashSet() {
map = new HashMap<>();
}
該實現是非同步的。
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
LinkedHashSet
基於Hash和雙向連結串列的實現方試。雙向連結串列定義了集合的順序就是元表插入的序。可以為null。
元素的順序不會因為重複新增而改變。
該實現是非同步的。
TreeSet
基於TreeMap。
元素自然比較器排序（預設向上排序）,或通過建立時提供的比較器比較序。
public TreeSet() {
this(new TreeMap<E,Object>());
}
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
該實現是非同步的。
Map
匹配鍵值對的物件，不能包含重複的值，每個鍵只能匹配一個值。
HashMap
基於Hash表的實現方式。鍵值對都可以為空。
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)
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) // -1 for 1st
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 key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
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;
}
}
HashTable
基於Hash表的實現方式。鍵值對都不可以為空。
該實現是同步的。
LinkedHashMap
基於Hash和雙向連結串列的實現方試。雙向連結串列定義了集合的順序就是元表插入的序。可以為null。
元素的順序不會因為重複新增而改變。