集合框架

ArrayList

基於jdk1.8.0_20

繼承關係圖

ArrayList的定義

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java
 
.io.Serializable

ArrayList的底層使用Object陣列來儲存的

transient Object[] elementData;

以前聽說ArrayList的初始大小為10，應該是以前的版本，我這個版本中ArrayList如果不指定大小時預設為空

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

在這裡主要關注一下自動擴容的實現

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    //確保陣列大小超過size + numNew
    ensureCapacityInternal(size + numNew);
    //實現陣列複製，a是源陣列，0是源陣列要複製的起始位置，elementData是目的陣列
    //size是目的陣列放置的起始位置，numNew複製的長度
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    //如果c為空則返回false,不為空則返回true
 

    return numNew != 0;
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

增加一個元素或者增加好幾個元素都會在呼叫ensureCapacityInternal方法來確保陣列大小足夠大，可以確定在ensureCapacityInternal方法裡面實現了自動擴容

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;

private void ensureCapacityInternal(int minCapacity) {

    //目前陣列為空
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //要求的容量大小和10取最大值
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    //這個是出於2種考慮
    //如果需要的容量大於目前的容量，就需要擴容
    //如果minCapacity溢位，即minCapacity為負數，就不擴容
    //minCapacity為負數的一種情況是addAll(Collection<? extends E> c)傳入的引數已經溢位了
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//之所以定義為Integer.MAX_VALUE - 8，是因為VM會保留一些頭結點在陣列開頭
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //>>是右移運算子，相當於除以2，因此新容量是舊容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //這裡需要分為2種情況
    //1.擴容還不滿足，直接將新容量設為需要的容量
    //2.newCapacity溢位，變為負數，擴充容量擴的太大了
    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);
}

private static int hugeCapacity(int minCapacity) {
    //溢位了，minCapacity的值大於int能儲存的最大值，用int儲存會變為負數
    //這裡minCapacity之所以為負數，可能是因為vm進行了一些操作
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

這個類實現陣列複製用的是System.arraycopy方法，這個方法複製比較快，因為是對記憶體直接進行復制，減少了for迴圈中的定址時間

//實現陣列複製，a是源陣列，0是源陣列要複製的起始位置，elementData是目的陣列
//size是目的陣列放置的起始位置，numNew複製的長度
System.arraycopy(a, 0, elementData, size, numNew);

LinkedList

基於jdk1.8.0_20

繼承關係圖

LinkedList的定義

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

LinkedList採用的雙向連結串列結構，因此在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;
    }
}

定義的變數為

//連結串列的長度
transient int size = 0;
//連結串列的頭結點
transient Node<E> first;
//連結串列的尾結點
transient Node<E> last;

增加元素的方法，addFirst，addLast，add都很類似，分析一個

public void addFirst(E e) {
    linkFirst(e);
}

private void linkFirst(E e) {

    //把連結串列的頭結點放到f這個中途變數
    final Node<E> f = first;
    //構造結點，前向指標為null，元素為e，後向指標指到f
    final Node<E> newNode = new Node<>(null, e, f);
    //插入的結點程式設計頭結點
    first = newNode;
    //如果原先頭結點為空
    if (f == null)
        //構造的結點不僅為頭結點，也是尾結點
        last = newNode;
    else
        //原先頭結點的前向指標指向構造的結點
        f.prev = newNode;
    //元素個數加1
    size++;
    //每次對元素進行操作時，這個都會增加1，主要為了迭代器校驗錯誤使用
    modCount++;
}

刪除元素的方法

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;
}

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.prev和x.next賦值為null，LZ猜是為了加速垃圾回收，但沒有實際測試
    x.item = null;
    size--;
    modCount++;
    return element;
}

獲取元素的方法

public E get(int index) {
    //檢查下標是否越界
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    // assert isElementIndex(index);
    //size >> 1和size / 2一個效果，因為將位右移一位相當於除2
    //在前半段，正向遍歷
    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;
    }
}

分析原始碼可知，通過get方式遍歷LinkedList是一種很低效的方式，因為每找一個元素都是從頭或者尾開始的，最好採用foreach或迭代器方式

Hashtable

基於jdk1.7.0_80

建構函式，預設初始容量為11

public Hashtable(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);

    if (initialCapacity==0)
        initialCapacity = 1;
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    initHashSeedAsNeeded(initialCapacity);
}

public Hashtable() {
    this(11, 0.75f);
}

put

public synchronized V put(K key, V value) {
    //value為null丟擲空指標異常
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry tab[] = table;
    int hash = hash(key);
    //7FFFFFFF的二進位制為1111111111111111111111111111111
    //hash & 0x7FFFFFFF是為了保hash值始終為正數
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            V old = e.value;
            e.value = value;
            return old;
        }
    }

    modCount++;
    //數量已經達到閾值
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();
        //table的值已經變化
        tab = table;
        //重新進行hash
        hash = hash(key);
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    //取出目前連結串列第一位
    Entry<K,V> e = tab[index];
    //將新增加的值變為第一個值
    tab[index] = new Entry<>(hash, key, value, e);
    count++;
    return null;
}

和HashMap的區別

get

public synchronized V get(Object key) {
    Entry tab[] = table;
    int hash = hash(key);
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return e.value;
        }
    }
    return null;
}

這裡put和get方法都沒有對key進行空值判斷，是因為key為null呼叫hash會丟擲空指標異常

private int hash(Object k) {
    // hashSeed will be zero if alternative hashing is disabled.
    return hashSeed ^ k.hashCode();
}

Vector

基於jdk1.8.0_20

Stack

基於jdk1.8.0_20

ArrayDeque

基於jdk1.8.0_20

參考部落格