Vector的浅析

　　Vector 可实现自动增长的对象数组。java.util.vector 提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。

　　Vector每次默认扩充为原来的2倍，ArrayList默认扩充为原来的1.5倍。Vector是同步的，ArrayList不是同步的。
　　Vector类的核心声明如下：

public class Vector<E> extends AbstractList<E> implements List<E>,
		RandomAccess, Cloneable, java.io.Serializable {
	protected Object[] elementData;// 保存Vector中数据的数组
	protected int elementCount;// 实际数据的数量
	protected int capacityIncrement;// 容量增长系数
	private static final long serialVersionUID = -2767605614048989439L;
}

 　　Vector类具有构造函数：

　　　　　public Vector() {
		this(10);
	}
	// 指定Vector容量大小的构造函数
	public Vector(int initialCapacity) {
		this(initialCapacity, 0);
	}
	// 指定Vector"容量大小"和"增长系数"的构造函数
	public Vector(int initialCapacity, int capacityIncrement) {
		super();
		if (initialCapacity < 0)
			throw new IllegalArgumentException("Illegal Capacity:"+ initialCapacity);
		this.elementData = new Object[initialCapacity];
		this.capacityIncrement = capacityIncrement;
	}

	// 指定集合的Vector构造函数。
	public Vector(Collection<? extends E> c) {
		// 获取“集合(c)”的数组，并将其赋值给elementData
		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 class Vector<E> extends AbstractList<E> implements List<E>,
		RandomAccess, Cloneable, java.io.Serializable {
	...
	// 将数组Vector的全部元素都拷贝到数组anArray中
	public synchronized void copyInto(Object[] anArray) {
		System.arraycopy(elementData, 0, anArray, 0, elementCount);
	}
	public synchronized void trimToSize() {
		modCount++;
		int oldCapacity = elementData.length;
		if (elementCount < oldCapacity) {
			elementData = Arrays.copyOf(elementData, elementCount);
		}
	}
	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);
		}
	}
	public synchronized void ensureCapacity(int minCapacity) {
		modCount++;
		ensureCapacityHelper(minCapacity);
	}

	// 设置容量值为 newSize
	public synchronized void setSize(int newSize) {
		modCount++;
		if (newSize > elementCount) {
			// 若 "newSize 大于 Vector容量"，则调整Vector的大小。
			ensureCapacityHelper(newSize);
		} else {
			// 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null
			for (int i = newSize; i < elementCount; i++) {
				elementData[i] = null;
			}
		}
		elementCount = newSize;
	}

　　	...

	// 返回“Vector中全部元素对应的Enumeration”
	public Enumeration<E> elements() {
		// 通过匿名类实现Enumeration
		return new Enumeration<E>() {
			int count = 0;
			// 是否存在下一个元素
			public boolean hasMoreElements() {
				return count < elementCount;
			}
			// 获取下一个元素
			public E nextElement() {
				synchronized (Vector.this) {
					if (count < elementCount) {
						return (E) elementData[count++];
					}
				}
				throw new NoSuchElementException("Vector Enumeration");
			}
		};
	}
	
	// 删除index位置的元素
	public synchronized void removeElementAt(int index) {
		modCount++;
		if (index >= elementCount) {
			throw new ArrayIndexOutOfBoundsException(index + " >= "+ elementCount);
		} else if (index < 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 */
	}

	// 在index位置处插入元素(obj)
	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++;
	}

	// 在Vector中查找并删除元素obj。
	// 成功的话，返回true；否则，返回false。
	public synchronized boolean removeElement(Object obj) {
		modCount++;
		int i = indexOf(obj);
		if (i >= 0) {
			removeElementAt(i);
			return true;
		}
		return false;
	}

	// 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
	public synchronized <T> T[] toArray(T[] a) {
		// 若数组a的大小 < Vector的元素个数；
		// 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中
		if (a.length < elementCount)
			return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

		// 若数组a的大小 >= Vector的元素个数；
		// 则将Vector的全部元素都拷贝到数组a中。
		System.arraycopy(elementData, 0, a, 0, elementCount);

		if (a.length > elementCount)
			a[elementCount] = null;

		return a;
	}

	// 设置index位置的值为element。并返回index位置的原始值
	public synchronized E set(int index, E element) {
		if (index >= elementCount)
			throw new ArrayIndexOutOfBoundsException(index);
		Object oldValue = elementData[index];
		elementData[index] = element;
		return (E) oldValue;
	}

	// 删除Vector中的元素o
	public boolean remove(Object o) {
		return removeElement(o);
	}

	// 在index位置添加元素element
	public void add(int index, E element) {
		insertElementAt(element, index);
	}

	// 删除index位置的元素，并返回index位置的原始值
	public synchronized E remove(int index) {
		modCount++;
		if (index >= elementCount)
			throw new ArrayIndexOutOfBoundsException(index);
		Object 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 (E) oldValue;
	}

	// 返回Vector是否包含集合c
	public synchronized boolean containsAll(Collection<?> c) {
		return super.containsAll(c);
	}

	// 将集合c添加到Vector中
	public synchronized boolean addAll(Collection<? extends E> c) {
		modCount++;
		Object[] a = c.toArray();
		int numNew = a.length;
		ensureCapacityHelper(elementCount + numNew);
		// 将集合c的全部元素拷贝到数组elementData中
		System.arraycopy(a, 0, elementData, elementCount, numNew);
		elementCount += numNew;
		return numNew != 0;
	}

	// 删除集合c的全部元素
	public synchronized boolean removeAll(Collection<?> c) {
		return super.removeAll(c);
	}

	// 删除“非集合c中的元素”
	public synchronized boolean retainAll(Collection<?> c) {
		return super.retainAll(c);
	}

	// 从index位置开始，将集合c添加到Vector中
	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中fromIndex(包括)到toIndex(不包括)的子集
	public synchronized List<E> subList(int fromIndex, int toIndex) {
		return Collections.synchronizedList(super.subList(fromIndex, toIndex),this);
	}

	// 删除Vector中fromIndex到toIndex的元素
	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;
	}

	// java.io.Serializable的写入函数
	private synchronized void writeObject(java.io.ObjectOutputStream s)
			throws java.io.IOException {
		s.defaultWriteObject();
	}
}