Vector线程安全的ArrayList

?

public class Vector<E>    extends AbstractList<E>    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{    /**     * The array buffer into which the components of the vector are     * stored. The capacity of the vector is the length of this array buffer,     * and is at least large enough to contain all the vector's elements.     *     * <p>Any array elements following the last element in the Vector are null.     *     * @serial     */    protected Object[] elementData;    /**     * The number of valid components in this {@code Vector} object.     * Components {@code elementData[0]} through     * {@code elementData[elementCount-1]} are the actual items.     *     * @serial     */    protected int elementCount;    /**     * The amount by which the capacity of the vector is automatically     * incremented when its size becomes greater than its capacity.  If     * the capacity increment is less than or equal to zero, the capacity     * of the vector is doubled each time it needs to grow.     *     * @serial     */    protected int capacityIncrement;

?

/**     * Removes the first occurrence of the specified element in this Vector     * If the Vector does not contain the element, it is unchanged.  More     * formally, removes the element with the lowest index i such that     * {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such     * an element exists).     *     * @param o element to be removed from this Vector, if present     * @return true if the Vector contained the specified element     * @since 1.2     */    public boolean remove(Object o) {        return removeElement(o);    }

?

/**     * Removes the first (lowest-indexed) occurrence of the argument     * from this vector. If the object is found in this vector, each     * component in the vector with an index greater or equal to the     * object's index is shifted downward to have an index one smaller     * than the value it had previously.     *     * <p>This method is identical in functionality to the     * {@link #remove(Object)} method (which is part of the     * {@link List} interface).     *     * @param   obj   the component to be removed     * @return  {@code true} if the argument was a component of this     *          vector; {@code false} otherwise.     */    public synchronized boolean removeElement(Object obj) {modCount++;int i = indexOf(obj);if (i >= 0) {    removeElementAt(i);    return true;}return false;    }

?

/**     * Returns the element at the specified position in this Vector.     *     * @param index index of the element to return     * @return object at the specified index     * @throws ArrayIndexOutOfBoundsException if the index is out of range     *            ({@code index < 0 || index >= size()})     * @since 1.2     */    public synchronized E get(int index) {if (index >= elementCount)    throw new ArrayIndexOutOfBoundsException(index);return (E)elementData[index];    }

?

/**     * Appends the specified element to the end of this Vector.     *     * @param e element to be appended to this Vector     * @return {@code true} (as specified by {@link Collection#add})     * @since 1.2     */    public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;        return true;    }

?

/**     * This implements the unsynchronized semantics of ensureCapacity.     * Synchronized methods in this class can internally call this     * method for ensuring capacity without incurring the cost of an     * extra synchronization.     *     * @see #ensureCapacity(int)     */    private void ensureCapacityHelper(int minCapacity) {int oldCapacity = elementData.length;if (minCapacity > oldCapacity) {    Object[] oldData = elementData;    int newCapacity = (capacityIncrement > 0) ?(oldCapacity + capacityIncrement) : (oldCapacity * 2);        if (newCapacity < minCapacity) {newCapacity = minCapacity;    }            elementData = Arrays.copyOf(elementData, newCapacity);}    }