Java-集合（Vector类）

Vector的基本介绍

1）Vactor类的定义；

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

2）Vector底层也是一个对象数组；

protected Object[] elementData;

3）Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized；

private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

4）在开发中，需要线程同步安全时，考虑使用Vector。

Vector与ArrayList的比较

	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组 elementData;	jdk 1.2	线程不安全，效率高	无参构造，初始空间10，之后按照1.5倍扩容； 有参构造，初始空间为指定的值，之后按照1.5倍扩容。
Vector	可变数组 elementData;	jdk1.0	线程安全，效率不高	无参构造，初始空间为10，之后按照2倍扩容； 一个参数的构造，初始空间为指定的值，之后按照2倍扩容。 两个参数的构造，初始空间为第一个指定的值，扩容增量为第二个指定的值。

Vector源码解读

测试代码

package com.pero.list_;

import java.util.Vector;

/**
 *
 * @author Pero
 * @version 1.0
 */

public class Vector_ {
    public static void main(String[] args) {

        //无参构造
        //Vector vector = new Vector();
        //有参构造
        //Vector vector = new Vector(8);
        Vector vector = new Vector(8,2);

        for (int i = 1; i <= 10; i++) {
            vector.add(i);
        }

        for (int i = 11; i <=20 ; i++) {
            vector.add(i);
        }

    }
}

源码解读

Vector类无参构造器添加元素：

1）执行构造器（调用无参构造器，执行tihis（10）语句，调用一个参数的构造器，创然后调用两个参数的构造器，调用父类构造器，判断初始空间的大小，当小于0时抛出异常，指定可变数组elementData的空间大小，传入指定扩容的大小）；

public Vector() {
        this(10);
    }

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

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

2）执行add（）方法，添加元素（第一，自动装箱将int类型转换成Integer类型；第二，执行public synchronized boolean add(E e) 方法，modCount++记录集合的修改次数；第三，执行private void ensureCapacityHelper(int minCapacity) 方法，判断集合是否需要扩容，如不需要执行elementData[elementCount++] = e，开始添加元素；如需要扩容，执行private void grow(int minCapacity)方法，首先将elementData数组的长度赋值给oldCapacity，设定一个新的容量newCapacity，判断定义增量的值capacityIncrement是否大于0，如果满足条件，则newCapacity的值为oldCapacity的值+capacityIncrement的值，如果不满足条件，则新容量newCapacity的值是原来容量2倍（oldCapacity+oldCapacity）；第四，对新的容量进行判断，首先判断是否小于0，如果满足条件则将初始化minCapacity的值传给newCapacity，如果不满足条件则执行下一条判断，判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE，如果满足条件，执行private static int hugeCapacity(int minCapacity)，首先判断minCapacity是否小于0，如果满足条件则抛出异常，如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE，如果是则返回Integer.MAX_VALUE（2147483647），如果否则返回MAX_ARRAY_SIZE（2147483639），将值赋值给新的容量newCapacity；第五，将原来的elementData数组中的信息拷贝到新的elementData数组中，并进行扩容；第六，将新元素添加到扩容后的集合中）；

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

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);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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类一个参数构造器添加元素：

1）执行构造器（调用一个参数的构造器，创然后调用两个参数的构造器，调用父类构造器，判断初始空间的大小，当小于0时抛出异常，指定可变数组elementData的空间大小，传入指定扩容的大小）；

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

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

2）执行add（）方法，添加元素（第一，自动装箱将int类型转换成Integer类型；第二，执行public synchronized boolean add(E e) 方法，modCount++记录集合的修改次数；第三，执行private void ensureCapacityHelper(int minCapacity) 方法，判断集合是否需要扩容，如不需要执行elementData[elementCount++] = e，开始添加元素；如需要扩容，执行private void grow(int minCapacity)方法，首先将elementData数组的长度赋值给oldCapacity，设定一个新的容量newCapacity，判断定义增量的值capacityIncrement是否大于0，如果满足条件，则newCapacity的值为oldCapacity的值+capacityIncrement的值，如果不满足条件，则新容量newCapacity的值是原来容量2倍（oldCapacity+oldCapacity）；第四，对新的容量进行判断，首先判断是否小于0，如果满足条件则将初始化minCapacity的值传给newCapacity，如果不满足条件则执行下一条判断，判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE，如果满足条件，执行private static int hugeCapacity(int minCapacity)，首先判断minCapacity是否小于0，如果满足条件则抛出异常，如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE，如果是则返回Integer.MAX_VALUE（2147483647），如果否则返回MAX_ARRAY_SIZE（2147483639），将值赋值给新的容量newCapacity；第五，将原来的elementData数组中的信息拷贝到新的elementData数组中，并进行扩容；第六，将新元素添加到扩容后的集合中）；

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);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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类一个参数构造器添加元素：

1）执行构造器（调用父类构造器，判断初始空间的大小，当小于0时抛出异常，指定可变数组elementData的空间大小，传入指定扩容的大小）；

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

2）执行add（）方法，添加元素（第一，自动装箱将int类型转换成Integer类型；第二，执行public synchronized boolean add(E e) 方法，modCount++记录集合的修改次数；第三，执行private void ensureCapacityHelper(int minCapacity) 方法，判断集合是否需要扩容，如不需要执行elementData[elementCount++] = e，开始添加元素；如需要扩容，执行private void grow(int minCapacity)方法，首先将elementData数组的长度赋值给oldCapacity，设定一个新的容量newCapacity，判断定义增量的值capacityIncrement是否大于0，如果满足条件，则newCapacity的值为oldCapacity的值+capacityIncrement的值，如果不满足条件，则新容量newCapacity的值是原来容量2倍（oldCapacity+oldCapacity）；第四，对新的容量进行判断，首先判断是否小于0，如果满足条件则将初始化minCapacity的值传给newCapacity，如果不满足条件则执行下一条判断，判断newCapacity的值是否大于集合的最大容量MAX_ARRAY_SIZE，如果满足条件，执行private static int hugeCapacity(int minCapacity)，首先判断minCapacity是否小于0，如果满足条件则抛出异常，如果不满足条件判断minCapacity是否MAX_ARRAY_SIZE，如果是则返回Integer.MAX_VALUE（2147483647），如果否则返回MAX_ARRAY_SIZE（2147483639），将值赋值给新的容量newCapacity；第五，将原来的elementData数组中的信息拷贝到新的elementData数组中，并进行扩容；第六，将新元素添加到扩容后的集合中）；

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);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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;
    }