Java中的Vector详细解读

    public Vector() {
        this(10);
    }

    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        //如果初始容量小于0，抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //指定容量
        this.elementData = new Object[initialCapacity];
        //指定增量
        this.capacityIncrement = capacityIncrement;
    }

    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

    public synchronized boolean add(E e) {
        //AbstractList中的变量
        modCount++;
        //确保数组容量是否足够
        ensureCapacityHelper(elementCount + 1);
        //把元素添加到数组中
        elementData[elementCount++] = e;
        return true;
    }

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        //旧数组的长度
        int oldCapacity = elementData.length;
        //如果指定了增量，则新数组长度=旧数组长度+增量；如果没有指定容量，则新数组长度=旧数组长度2倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        //判断新容量减去最小容量是否小于0，如果是第一次调用add，则必然小于
        if (newCapacity - minCapacity < 0)
            //将最小容量赋给新容量
            newCapacity = minCapacity;
        /判断新容量减去最大数组大小是否大于0，如果时则计算出一个超大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //调用数组工具类方法，创建一个新数组，将新数组的地址赋值给elementData
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        //如果最小容量小于0，抛出异常；否则就比较并返回
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    //在指定位置添加元素
    public void add(int index, E element) {
        insertElementAt(element, index);
    }
    //添加元素到指定位置
    public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        //检查位置合法性
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        //判断是否需要扩容
        ensureCapacityHelper(elementCount + 1);
        //拷贝数组
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        //添加元素
        elementData[index] = obj;
        elementCount++;
    }

    public boolean remove(Object o) {
        return removeElement(o);
    }
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        //获取该元素所在的数组下标
        int i = indexOf(obj);
        //如果该元素存在，则移除元素
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }
    public synchronized void removeElementAt(int index) {
        modCount++;
        //如果下标越界，抛出异常
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {        //下标小于0，抛出异常
            throw new ArrayIndexOutOfBoundsException(index);
        }
        //删除元素
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

    public synchronized E set(int index, E element) {
        //判断合法性
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        //修改旧值
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        return elementData(index);
    }