Java集合-Vector

Vector（部分内容参考于：参考文章）

【介绍】

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

VectoVector 是矢量队列，它是JDK1.0版本添加的类。它继承于AbstractList，实现了List、RandomAccess、Cloneable、 Serializable等接口。

（1）Vector 继承了AbstractList，实现了List接口。

（2）Vector实现了RandmoAccess接口，即提供了随机访问功能。（可以通过元素的序号快速获取元素对象）

（3）Vector 实现了Cloneable接口，即实现克隆功能。（实现clone()函数）

（4）Vector 实现Serializable接口，表示支持序列化。

和ArrayList不同，Vector中的操作是线程安全的。

---

【使用】

一、构造方法（4个）

（1）无参构造器

（2）传入一个整数 initialCapacity 的有参构造器

（3）传入两个整数的 initialCapacity 、 capacityIncrement 的有参构造器

//前三个在下面的源码分析

（4）传入一个集合的有参构造器

public Vector(Collection<? extends E> c) {
    Object[] a = c.toArray();
    elementCount = a.length;
    if (c.getClass() == ArrayList.class) {
        elementData = a;
    } else {
        elementData = Arrays.copyOf(a, elementCount, Object[].class);
    }
}

二、内部结构

Vector的数据结构和ArrayList差不多，它包含了3个成员变量：elementData , elementCount， capacityIncrement。

(1) elementData： 是"Object[]类型的数组"，它保存了添加到Vector中的元素。elementData是个动态数组，如果初始化Vector时，没指定动态数组的>大小，则使用默认大小10。随着Vector中元素的增加，Vector的容量也会动态增长，capacityIncrement是与容量增长相关的增长系数，具体的增长方式，请参考源码。

(2) elementCount ：是动态数组的实际大小。

(3) capacityIncrement ： 是动态数组的增长系数。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement。

三、API（Vector常用方法）

1. 由于 Vector类实现了RandmoAccess接口，可根据索引来访问数组里的元素：

   get()方法：

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

---

【源码分析】

1. 无参构造器：（实际上使用的是有参构造器，构造初始容量为 10 的 Vector对象）

    public Vector() {
    	this(10);
    }
   

2. 有参构造器：传入一个整型数据，用作初始化的容量

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

3. 传入两个整型数据的有参构造器：

   （1）第二个参数的用处：

    /**
     * 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;
   

   capacityIncrement出现的地方：

    capacityIncrement > 0 ? capacityIncrement : oldCapacity
    //默认 capacityIncrement 是 0 ，故在扩容的时候是按照两倍扩容（+ 旧容量），
    //若设置了capacityIncrement，则按照这个数值来每次扩容。
   

   （2）源码：

    public Vector(int initialCapacity, int capacityIncrement) {
    	super();
    	if (initialCapacity < 0)
    		throw new IllegalArgumentException("Illegal Capacity: "+
    										   initialCapacity);
    	this.elementData = new Object[initialCapacity];
    	this.capacityIncrement = capacityIncrement;
    }
   

4. 扩容操作：

    public synchronized boolean add(E e) {
    	modCount++;
    	add(e, elementData, elementCount);
    	return true;
    }
   
   
    private void add(E e, Object[] elementData, int s) {
    	if (s == elementData.length)
    		elementData = grow();
    	elementData[s] = e;
    	elementCount = s + 1;
    }
   
    private Object[] grow() {
    	return grow(elementCount + 1);
    }
   
    private Object[] grow(int minCapacity) {
    	int oldCapacity = elementData.length;
    	int newCapacity = ArraysSupport.newLength(oldCapacity,
    			minCapacity - oldCapacity, /* minimum growth */
    			capacityIncrement > 0 ? capacityIncrement : oldCapacity
    									   /* preferred growth */);
    	return elementData = Arrays.copyOf(elementData, newCapacity);
    }