JDK1.7

JDK1.8

ArrayList (jdk1.7、jdk1.8)

數(shù)據(jù)結(jié)構(gòu)

jdk1.7
//數(shù)據(jù)存儲(chǔ)結(jié)構(gòu)
private transient Object[] elementData;
jdk1.8
//數(shù)據(jù)存儲(chǔ)結(jié)構(gòu)
transient Object[] elementData;

默認(rèn)容量

jdk1.7
public ArrayList() {
    this(10);
}
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}

jdk1.8
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// size默認(rèn)為0
private int size;
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

擴(kuò)容

jdk1.7
public boolean add(E e) {
    // 擴(kuò)容方法
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // 大于當(dāng)前數(shù)組長度才進(jìn)行擴(kuò)容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
// 擴(kuò)容正常最大值（-8因?yàn)閖ava有保留）
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// minCapacity-->add、addAll 方法計(jì)算需要最小容量
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新數(shù)組大小為原有數(shù)組1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 默認(rèn)擴(kuò)容大小、數(shù)組需要容量最小值 判斷取最大值
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // System.arraycopy native方法
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// 獲取數(shù)組長度最最最大值
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}


jdk1.8
// 默認(rèn)擴(kuò)容大小
private static final int DEFAULT_CAPACITY = 10;
public boolean add(E e) {
    // 擴(kuò)容方法
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}
//擴(kuò)容內(nèi)部方法
private void ensureCapacityInternal(int minCapacity) {
    // 對(duì)象為空{(diào)},本方法為第一次調(diào)用。比較默認(rèn)容量和參數(shù)指定容量,取最大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 最小長度為默認(rèn)的10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
// 擴(kuò)容判斷方法
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 大于數(shù)組長度才進(jìn)行擴(kuò)容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
// 擴(kuò)容正常最大值（-8因?yàn)閖ava有保留）
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//minCapacity-->add、addAll 方法計(jì)算需要最小容量
private void grow(int minCapacity) {
     int oldCapacity = elementData.length;
    // 新數(shù)組大小為原有數(shù)組1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
     // 默認(rèn)擴(kuò)容大小、數(shù)組需要容量最小值 判斷取最大值
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
     // System.arraycopy native方法
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// 獲取數(shù)組長度最最最大值
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

Vector (jdk1.7、jdk1.8)

數(shù)據(jù)結(jié)構(gòu)

jdk1.7
  //數(shù)據(jù)結(jié)構(gòu)
  protected Object[] elementData;
  // 容量增量
  protected int capacityIncrement;

jdk1.8
 // 數(shù)據(jù)結(jié)構(gòu)
 protected Object[] elementData
  //容量增量
 protected int capacityIncrement;

默認(rèn)容量

jdk1.7
// 默認(rèn)10
public Vector() {
    this(10);
}
// 容量增量為0
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

jdk1.8
// 同jdk1.7

擴(kuò)容

jdk1.7
// 同步add方法
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
// 擴(kuò)容判斷方法
private void ensureCapacityHelper(int minCapacity) {
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 擴(kuò)容方法
private void grow(int minCapacity) { 
    int oldCapacity = elementData.length;
    // 擴(kuò)容增量大于0,按照指定的擴(kuò)容增量增加,反之在原有長度上增加1倍
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    // 以下同ArrayList
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

jdk1.8
// 同jdk1.7

LinkedList (jdk1.7、jdk1.8)

數(shù)據(jù)結(jié)構(gòu)

jdk1.7

transient int size = 0;
transient Node<E> first;// 第一個(gè)元素
transient Node<E> last;// 最后一個(gè)元素
private static class Node<E> {
    E item;//本身元素
    Node<E> next;// 下一個(gè)元素對(duì)象引用
    Node<E> prev;//上一個(gè)元素對(duì)象引用

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

 jdk1.8
 //同jdk1.7

默認(rèn)容量

無默認(rèn)容量(鏈表結(jié)構(gòu))

擴(kuò)容

無需擴(kuò)容,只要內(nèi)存夠大, 就可以無限制，前提是不考慮效率問題