Java中的集合之ArrayList，Vector和Stack

这三个集合类型，其底层都是数组实现的。讨论集合关注的问题：

1. 底层数据结构
2. 增删改查方式
3. 初始容量，扩容方式，扩容时机
4. 线程安全与否
5. 是否允许空，是否允许重复，是否有序

ArrayList

ArrayList是实现List接口的动态数组。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个数组都有一个容量，由一个数组维护，初始的容量为10（在第一个元素添加进来时扩容），也可以在初始化new操作时给定。ArrayList继承自AbstractList，实现了List,RandomAccess,Cloneable,.Serializable接口。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

每次添加新的元素时：先判断合法性，会判断数组的长度，当超过当前的容量大小时，则会扩容一个新的1.5倍的数组，使用Arrays.copyOf将对象复制到新数组中。内部数组elementData使用transient修饰，即进行序列化时，只复制有值的内容，可以节省空间。还可以插入到制定的位置下，同样操作，使用System.copyOf操作，Arrays.copyOf最终调用的也是该方法。删除也会拷贝，清空则是置为null。

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

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
//扩容
 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);
    }

ArrayList的所有方法都没有加锁或同步控制，所以是非线性安全的。可以在创建时，使用Collection.synchronizedList使其对外线程同步。内置一个modCount进行控制，对内部数组进行了增删改动后，该值会++，后续使用迭代器时判断与expectedModCount不相同则抛出异常。“Fast-Fail机制”

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

 

Vector

Vector是实现了List的动态可变集合。Vector同样继承自AbstractList，实现了List,RandomAccess,Cloneable,.Serializable接口。基本和ArrayList类似，内部也是一个对象数组elementData维护，不过没有transient，意味着序列化全部内容。

初始化，默认直接为10，不需要第一次加载。另外，除了初始化大小外，还可以制定增长的宽度。

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

    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */
    public Vector() {
        this(10);
    }

新增元素时，同样会对modCount++，同时判断当前的大小，加1时超过容量则进行扩容。如果设置了扩容增量大小则按该值，否则就扩容成原来的两倍，同样是使用了System.copyOf进行操作。扩容完毕后进行容量的更新。

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

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

Vector中所有对数据进行修改的方法都加了synchronized修饰，来保证线程安全性。

public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

 

Stack

Stack是一种栈结构，在Java中其只继承自Vector。栈很常见，就是一种先进后出，或者说后进先出的数据结构。Stack使用了Vector中的数组维护数据结构，在Vector外只实现了pop,push,peek,empty,search5个另外的方法。

同样地，这些方法基本都是使用synchronized修饰，因此Stack是线性安全的。

public synchronized E pop() {
        E  obj;
        int len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }
    /* @return  the object at the top of this stack (the last item
     *          of the <tt>Vector</tt> object).
     * @throws  EmptyStackException  if this stack is empty.
     */
    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

 

小结：

总的来说，ArrayList实现了RandomAccess，所以随机访问快速；但是在进行插入或删除数据的时候，要使用System.copyOf进行大量的数据拷贝，浪费资源。且ArrayList线性不安全。

Vector同样可以随机读取，和ArrayList类似在增删数据时涉及大量拷贝，但是优点是线性安全的。

Stack用于一些特定的数据结构需求中。

参考文章