本文共 3626 字，大约阅读时间需要 12 分钟。

1、ArrayList

底层是Object的动态数组构成的。

jdk7：

jdk8

/**     * Constructs an empty list with an initial capacity of ten.     */    public ArrayList() {           this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {   };

扩容方式是1.5倍扩容，如果扩容完之后，需要的容量大小还不够的话，会直接扩容到所需要的容量大小。最大是Integer.MAX_VALUE

private void ensureCapacityInternal(int minCapacity) {           if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {           	// 第一次添加的时候进行数组容量的初始化赋值            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        ensureExplicitCapacity(minCapacity);    }/**     * 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);    }

总结：jdk7 ArrayList的对象的创建的同时，也立即对Oject数组进行了创建，jdk8 ArrayList的对象的创建的同时，并没有立即创建Oject数组，而是在添加元素的时候，才进行object数组的创建，节省内存。

2、LinkededList

底层是双向链表构成的。 这个没有什么好说的…

内部是node节点

private static class Node
   
     {           E item;        Node
    
      next;        Node
     
       prev;        Node(Node
      
        prev, E element, Node
       
         next) {               this.item = element;            this.next = next;            this.prev = prev;        }    }	// 添加节点    public void addLast(E e) {           linkLast(e);    }        /**     * Links e as last element.     */    void linkLast(E e) {           final Node
        
          l = last; final Node
         
           newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; }
         
        
       
      
     
    
   

3、Vector

底层是Object的动态数组构成的。

jdk8 Vector的构造方法初始化会创建容器大小为10的Object数组。

public Vector() {           this(10);    }    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;    }

添加数据是线程安全的，扩容方式是2倍扩容，如果扩容完之后，需要的容量大小还不够的话，会直接扩容到所需要的容量大小。最大是Integer.MAX_VALUE。

public synchronized boolean add(E e) {           modCount++;        ensureCapacityHelper(elementCount + 1);        elementData[elementCount++] = e;        return true;    }    private void grow(int minCapacity) {           // overflow-conscious code        int oldCapacity = elementData.length;        // 原来容量的2倍进行扩容        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);    }