ArrayList、LinkedList、Vector的源码分析

1、ArrayList

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

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

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

jdk8
ArrayList的构造方法初始化不会实例化数组容量大小。

   /**
     * 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
第一次调用add方法时候，才进行实例初始化容量为10的大小

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

	// 添加节点
    public void addLast(E e) {
        linkLast(e);
    }
    
    /**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> 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);
    }