Vector的浅析

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

　　	public synchronized int capacity() {
		return elementData.length;
	}

	// 返回“Vector的实际大小”，即Vector中元素个数
	public synchronized int size() {
		return elementCount;
	}
	public synchronized boolean isEmpty() {
		return elementCount == 0;
	}

	// 返回“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");
			}
		};
	}

	// 返回Vector中是否包含对象(o)
	public boolean contains(Object o) {
		return indexOf(o, 0) >= 0;
	}
	// 从index位置开始向后查找元素(o)。
	// 若找到，则返回元素的索引值；否则，返回-1
	public synchronized int indexOf(Object o, int index) {
		if (o == null) {
			// 若查找元素为null，则正向找出null元素，并返回它对应的序号
			for (int i = index; i < elementCount; i++)
				if (elementData[i] == null)
					return i;
		} else {
			// 若查找元素不为null，则正向找出该元素，并返回它对应的序号
			for (int i = index; i < elementCount; i++)
				if (o.equals(elementData[i]))
					return i;
		}
		return -1;
	}

	// 查找并返回元素(o)在Vector中的索引值
	public int indexOf(Object o) {
		return indexOf(o, 0);
	}

	// 从后向前查找元素(o)。并返回元素的索引
	public synchronized int lastIndexOf(Object o) {
		return lastIndexOf(o, elementCount - 1);
	}

	// 从后向前查找元素(o)。开始位置是从前向后的第index个数；
	// 若找到，则返回元素的“索引值”；否则，返回-1。
	public synchronized int lastIndexOf(Object o, int index) {
		if (index >= elementCount)
			throw new IndexOutOfBoundsException(index + " >= " + elementCount);

		if (o == null) {
			// 若查找元素为null，则反向找出null元素，并返回它对应的序号
			for (int i = index; i >= 0; i--)
				if (elementData[i] == null)
					return i;
		} else {
			// 若查找元素不为null，则反向找出该元素，并返回它对应的序号
			for (int i = index; i >= 0; i--)
				if (o.equals(elementData[i]))
					return i;
		}
		return -1;
	}

	// 返回Vector中index位置的元素。
	// 若index月结，则抛出异常
	public synchronized E elementAt(int index) {
		if (index >= elementCount) {
			throw new ArrayIndexOutOfBoundsException(index + " >= "
					+ elementCount);
		}

		return (E) elementData[index];
	}

	// 获取Vector中的第一个元素。
	// 若失败，则抛出异常！
	public synchronized E firstElement() {
		if (elementCount == 0) {
			throw new NoSuchElementException();
		}
		return (E) elementData[0];
	}

	// 获取Vector中的最后一个元素。
	// 若失败，则抛出异常！
	public synchronized E lastElement() {
		if (elementCount == 0) {
			throw new NoSuchElementException();
		}
		return (E) elementData[elementCount - 1];
	}

	// 设置index位置的元素值为obj
	public synchronized void setElementAt(E obj, int index) {
		if (index >= elementCount) {
			throw new ArrayIndexOutOfBoundsException(index + " >= "
					+ elementCount);
		}
		elementData[index] = obj;
	}

	// 删除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++;
	}

	// 将“元素obj”添加到Vector末尾
	public synchronized void addElement(E obj) {
		modCount++;
		ensureCapacityHelper(elementCount + 1);
		elementData[elementCount++] = obj;
	}

	// 在Vector中查找并删除元素obj。
	// 成功的话，返回true；否则，返回false。
	// 本栏目更多精彩内容：http://www.bianceng.cn/Programming/Java/
	public synchronized boolean removeElement(Object obj) {
		modCount++;
		int i = indexOf(obj);
		if (i >= 0) {
			removeElementAt(i);
			return true;
		}
		return false;
	}

	// 删除Vector中的全部元素
	public synchronized void removeAllElements() {
		modCount++;
		// 将Vector中的全部元素设为null
		for (int i = 0; i < elementCount; i++)
			elementData[i] = null;

		elementCount = 0;
	}

	// 克隆函数
	public synchronized Object clone() {
		try {
			Vector<E> v = (Vector<E>) super.clone();
			// 将当前Vector的全部元素拷贝到v中
			v.elementData = Arrays.copyOf(elementData, elementCount);
			v.modCount = 0;
			return v;
		} catch (CloneNotSupportedException e) {
			// this shouldn‘t happen, since we are Cloneable
			throw new InternalError();
		}
	}

	// 返回Object数组
	public synchronized Object[] toArray() {
		return Arrays.copyOf(elementData, elementCount);
	}

	// 返回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位置的元素
	public synchronized E get(int index) {
		if (index >= elementCount)
			throw new ArrayIndexOutOfBoundsException(index);

		return (E) elementData[index];
	}

	// 设置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;
	}

	// 将“元素e”添加到Vector最后。
	public synchronized boolean add(E e) {
		modCount++;
		ensureCapacityHelper(elementCount + 1);
		elementData[elementCount++] = e;
		return true;
	}

	// 删除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
	public void clear() {
		removeAllElements();
	}

	// 返回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;
	}

	// 返回两个对象是否相等
	public synchronized boolean equals(Object o) {
		return super.equals(o);
	}

	// 计算哈希值
	public synchronized int hashCode() {
		return super.hashCode();
	}

	// 调用父类的toString()
	public synchronized String toString() {
		return super.toString();
	}

	// 获取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();
	}
}