Java 集合系列05 Vector集合

1. Vector介绍

　　Vector是一个矢量队列，继承AbstractList，实现List，Clonable，java.io.Serializable这些接口。

　　Vector集合底层也是采用了数组这种数据结构，和ArrayList集合不同的是，Vector集合中所有方法都被synchronized修饰，所以是线程安全的，现在保证线程安全有别的方案了，所有Vector集合使用较少了。

　　Vector构造函数

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

    //采用数据保存数据
    protected Object[] elementData;

    //默认构造函数，默认大小容量是10，当容量超出，自动扩容为原来的2倍
    Vector()

    //指定容量
    Vector(int initialCapacity)

    //capacity是Vector的默认容量，capacityIncrement是每次Vector容量增加时的增量值
    Vector(int initialCapacity, int capacityIncrement)

    //创建一个指定collection的Vector
    Vector(Collection<? extends E> c)

　　Vector所有方法都有synchronized关键字修饰，所以是线程安全的，但是效率低，现在保证线程安全有别的方案了，所以Vector使用较少了。

2.  Vector扩容机制

　　（1）无参数构造

public class Test{
    public static void main(String[] args) {
        Vector vector = new Vector();
        for (int i=0; i<10; i++){
            vector.add(i);
        }
        vector.add(11);
        vector.add(12);
    }
}

    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)    //数组长度初始化10与s不相等，所以不会扩容
            elementData = grow();
        elementData[s] = e;
        elementCount = s + 1;
    }

    private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

    private Object[] grow() {
        return grow(elementCount + 1);
    }

private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);    //capacityIncrement在构造函数中传入入为0
        if (newCapacity - minCapacity <= 0) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

　　a. 在无参数构造函数的情况下，会初始化容量10；在前10个元素添加时就不会进入grow中进行扩容；

　　b. 当添加第11个元素时，s与数组长度相等，则会进入grow()中，先进行新的容量大小的计算；

　　c. 在newCapacity()中新的容量大小计算，capacityIncreament在构造函数传入0，所以newCapacity的容量是oldCapacity容量大小的2倍；

　　d. 这样就返回到grow(int mincapacity)中，Arrays.copyOf了一个新的数组，数组容量的大小为新的容量，返回新的数组；

　　（2）有参构造

　　在有参构造时会调用有参数构造方法初始化一个给定容量大小的数组，如果添加数量超过了数组长度，则进行扩容，扩容机制还是与无参构造相同。

3. Vector实例

public static void main(String[] args) {
        List list = new Vector();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        list.add(600);
        list.add(700);
        list.add(800);
        list.add(900);
        list.add(1000);

        list.add(1100);

        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        List mylist = new ArrayList();
        Collections.synchronizedList(mylist);    //通过调用Collections工具类的synchronizedList方法
        mylist.add(100);                //可以把Arraylist集合转换为线程安全的
        mylist.add(200);
        mylist.add(300);
    }