java集合整理一（ArrayList）

java集合有Collection和Map，其中List和Set接口extends Collection，实现List接口和Set接口的类如下：

Collection

--List (有序，可重复)
    --Vector (数组，同步)
    --ArrayList (非同步情况下Vector的替代者，数组，不同步)
    --LinkedList (双向链表，不同步)

--Set (无序，不重复，最多一个null元素)
    --HashSet
    --LinkedHashSet
    --TreeSet

ArrayList

ArrayList使用动态数组实现。默认初始容量为10。不同步。（这里只分析了集合元素的添加）

ArrayList类的成员变量：

/**
 * 默认初始容量.
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 这个是定义的空数组，这里是当初始化数组大小为0的时候使用
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 这里是初始化没有设定大小的时候使用
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
    容量最大值
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

方法：

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

集合在添加元素时，通过ensureCapacityInternal()方法确保数组有空间可以存储。

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
 }

方法ensureCapacityInternal()中的判断是因为当通过 new ArrayList<>()创建集合时并没有初始化集合的容量大小，因此在第一次添加元素时对集合的容量大小进行初始化。

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
}

当集合大小不能确保保存新添加的元素时，需要进行扩容。ensureExplicitCapacity()方法判断是否需要进行扩容。

//真正的扩容操作
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //1.5倍扩容
        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);
}

grow()方法是对集合的大小进行扩容。

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

hugeCapacity()方法是对超大容量的判断，当超过了默认的最大数值，将会把Integer.MAX_VALUE赋值给newCapacity （也就是需要创建的容量大小）。

如有错误之处，欢迎指正。