Java 集合深入理解：Vector

都说Vector和ArrayList相同，只不过Vector是同步的，看下源码

Vector继承结构

public class Vector<E>     extends AbstractList<E>     implements List<E>, RandomAccess, Cloneable, java.io.Serializable {...}

Vector 和 ArrayList 一样，都是继承自 AbstractList。它是 Stack 的父类。

成员变量

底层实现是数组

protected Object[] elementData;

数组元素个数

protected int elementCount;

扩容时增长数量

protected int capacityIncrement;

Vector 的 4 种构造方法

//创建指定容量大小的数组，设置增长量。如果增长量为 非正数，扩容时会扩大两倍 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  public Vector(int initialCapacity) {     this(initialCapacity, 0); } //创建默认容量 10 的数组 public Vector() {     this(10); }  //创建一个包含指定集合的数组 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); }

Vector 的成员方法

//扩容，传入最小容量，跟 ArrayList.grow(int) 很相似，只是扩大量不同  private void grow(int minCapacity) {     int oldCapacity = elementData.length;     //如果增长量 capacityIncrement 不大于 0 ，就扩容 2 倍     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中的 5 种添加元素的方法

//尾部插入元素，同步的 public synchronized void addElement(E obj) {     modCount++;     ensureCapacityHelper(elementCount + 1);     elementData[elementCount++] = obj; }  public synchronized boolean add(E e) {     modCount++;     ensureCapacityHelper(elementCount + 1);     elementData[elementCount++] = e;     return true; }  private void ensureCapacityHelper(int minCapacity) {     // overflow-conscious code     if (minCapacity - elementData.length > 0)         grow(minCapacity); }  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 synchronized boolean addAll(Collection<? extends E> c) {     modCount++;     Object[] a = c.toArray();     int numNew = a.length;     ensureCapacityHelper(elementCount + numNew);     System.arraycopy(a, 0, elementData, elementCount, numNew);     elementCount += numNew;     return numNew != 0; } //添加一个结合到指定位置，同步的 public synchronized boolean addAll(int index, Collection<? extends E> c) {     modCount++;     if (index < 0 || index > elementCount)         throw new ArrayIndexOutOfBoundsException(index);      Object[] a = c.toArray();     int numNew = a.length;     ensureCapacityHelper(elementCount + numNew);      int numMoved = elementCount - index;     if (numMoved > 0)         System.arraycopy(elementData, index, elementData, index + numNew,                          numMoved);      System.arraycopy(a, 0, elementData, index, numNew);     elementCount += numNew;     return numNew != 0; }

Vector 中的删除方法（有些没贴）

public synchronized boolean removeElement(Object obj) {     modCount++;     int i = indexOf(obj);     if (i >= 0) {         removeElementAt(i);         return true;     }     return false; }  public synchronized void removeAllElements() {     modCount++;     // Let gc do its work     for (int i = 0; i < elementCount; i++)         elementData[i] = null;      elementCount = 0; }  public boolean remove(Object o) {     return removeElement(o); }  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; }  public void clear() {     removeAllElements(); }  public synchronized boolean removeAll(Collection<?> c) {     return super.removeAll(c); }  protected synchronized void removeRange(int fromIndex, int toIndex) {     modCount++;     int numMoved = elementCount - toIndex;     System.arraycopy(elementData, toIndex, elementData, fromIndex,                      numMoved);      // Let gc do its work     int newElementCount = elementCount - (toIndex-fromIndex);     while (elementCount != newElementCount)         elementData[--elementCount] = null; }

Vector 中的修改方法

//修改指定位置为指定元素 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 void setElementAt(E obj, int index) {     if (index >= elementCount) {         throw new ArrayIndexOutOfBoundsException(index + " >= " +                                                  elementCount);     }     //数组就是方便，直接更新就好了     elementData[index] = obj; }

Vector 中的查询

//查找 o 从指定位置 index 开始第一次出现的位置 public synchronized int indexOf(Object o, int index) {     if (o == null) {         for (int i = index ; i < elementCount ; i++)             if (elementData[i]==null)                 return i;     } else {         for (int i = index ; i < elementCount ; i++)             if (o.equals(elementData[i]))                 return i;     }     return -1; }