JDK9.0 Vector源码阅读记录

前言

Vector和ArrayList一样，本质上就是一个动态数组，当容量不够时便会进行扩容最大的长度不超过Integer的最大值(0x7fffffff).Vector是线程安全的．

Vector的继承体系

java.lang.Object
　　java.util.AbstractCollection
　　　　java.util.AbstractList
　　　　　　java.util.Vector

继承接口

Serializable,　//序列化
Cloneable,　　 //实现深拷贝
Collection, //集合
List,　//List
RandomAccess;//随即访问

子类

Stack;//栈

私有属性

protected Object[] elementData;//存放数据数组
protected int elementCount;//Vector中的元素数量
protected int capacityIncrement;//，每次扩容新增的容量

构造器

无参构造器，初始容量为10，每次扩容新增的容量为０

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

以其他集合进行初始化，容量为集合c的有效长度，每次扩容新增的容量为０

public Vector(Collection c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        // defend against c.toArray (incorrectly) not returning Object[]
        // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

如何实现线程安全

Vector在很多函数上都加了synchronized关键字实现访问同步，因此相对于ArrayList是线程安全的，当然相对的效率也会降低．

 public synchronized boolean add(E e)；
 public synchronized boolean removeElement(Object obj)
 ．．．．．．等

常用方法

Vetor也和ＡrrayList一样，也提供了添加删除查找等操作，也可以使用迭代器进行访问．更多的方法请参考源码，就不一一列出了．

扩容处理

这也是和ＡrrayList不一样的地方，
ＡrrayList每次都是进行1.5倍的扩容，因此可能会造成很大的内存浪费．
Vetor可以指定每次进行扩容的大小，如果capacityIncrement等于０，那么每次都会进行２倍的扩容，因此最好指定capacityIncrement的值，而且需要根据实际情况设定．设定小了，那么就会造成频繁的扩容处理，效率降低，设定大了，就会造成内存浪费．

 private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity <= 0) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

总结

1. Vector的本质上和ArrayList一样．是个动态数组
2. Vector可以被序列化
3. 可以实现深拷贝
4. 对访问方法进行同步处理，所以其是线程安全的
5. 可以设定每次扩容新增的容量大小，如果不设定，就会进行２倍扩容

相关文章

JDK9.0 ArrayList源码阅读记录
JDK9.0 LinkedList源码阅读记录
ArrayList和LinkedList性能比较
JDK9.0 Vector源码阅读记录
JDK9.0 Hashtable源码阅读记录
Java9.0 HashMap源码阅读记录
JDK9.0 HashSet源码阅读记录