所有集合基于jdk1.8，对源码稍做调整。

ArrayList

主要变量

     //默认容量
    private final int DEFAULT_CAPACITY = 10;
    //默认元素
    private final Object[] EMPTY_ELEMENTDATE = {};
    //元素
    transient Object[] elementData;
    //大小
    private int size;

构造方法

public ArrayList(int initialCapacity) {
        if(initialCapacity > 0){
            this.elementData = new Object[initialCapacity];
        }else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATE;
        }else {
            throw new IllegalArgumentException("初始容量错误:" + initialCapacity);
        }
    }

    public ArrayList() {
        this.elementData = EMPTY_ELEMENTDATE;
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if((size = elementData.length) != 0){
            if(elementData.getClass() != Object[].class){
                elementData = Arrays.copyOf(elementData, size, Object[].class);
            }
        }else{
            this.elementData = EMPTY_ELEMENTDATE;
        }
    }

第一个可以传入一个初始容量initialCapacity，ArrayList就会创建一个长度为initialCapacity的数据。
第二个直接将创建一个0长度数组。
第三个可以传入集合框架，要求泛型是该ArrayLIst泛型本身或其子类。

主要方法

add

    public boolean add(E e) {
        ensureCapacity(size + 1);
        //实际赋值
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacity(int capacity) {
        //元素为空数组，容量取最小为10
        if(elementData == EMPTY_ELEMENTDATE){
            capacity = Math.max(capacity, DEFAULT_CAPACITY);
        }
        //当所需容量大于当前数组长度时，扩容
        if(capacity > elementData.length){
            int oldCapacity = elementData.length;
            //扩容1.5倍
            int newCapacity = oldCapacity + oldCapacity >> 1;
            //扩容后还是小于所设容量，将所设容量设为新容量
            if(newCapacity < capacity){
                newCapacity = capacity;
            }
            //当扩容后大于数组最大大小
            else if (newCapacity > MAX_ARRAY_SIZE) {
                newCapacity = capacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
            }
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

get

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    /**
     * 范围check，数组越界则抛出异常
     * @param index
     */
    private void rangeCheck(int index) {
        if(index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index:" + index + ",Size:" + size);
        }
    }
    /**
     * 统一解除警告
     * @return
     */
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

Vector

Vector结构和ArrayList相似，提供了四个构造函数。多提供的构造函数为:

    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

第二个参数用于指定长度不够时扩容多少，当该值小于等于0时，Vector扩容2倍。而ArrayList是扩容1.5倍。

主要方法

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

方法前面都加了关键字synchronized，所有Vector是线程安全的，但是效率低。

Stack

Stack继承Vector，只提供了一个构造函数。

主要方法

    public E push(E item) {
        addElement(item);
        return item;
    }
    public synchronized E pop() {
        E       obj;
        int     len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }
    public synchronized E peek() {
        int     len = size();
        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

push用于添加一个元素，pop删除并返回最后一个元素。