Vector源码解读

Vector简介

 1.内部通过数组实现  
 2.通过synchronized同步方法，线程安全，适合多线程
  3.由于线程安全，效率不高  
 4.默认存放10个元素

 5.需要增加容量时候，默认新增加容量是元素Vector的大小 6.效率低，不推荐用 

属性

//内部通过Object数组存放元素
protected Object[] elementData;

//当前元素id
protected int elementCount;

//每次可增加容量大小
protected int capacityIncrement;

构造器 

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

initalCapacity初始化容量大小，capacityIncrement每次扩容的大小

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

初始指定容量大小

public Vector() {
        this(10);
    }

默认只能存放10个元素

/* @throws NullPointerException if the specified collection is null
     * @since   1.2
     */
    public Vector(Collection<? extends E> c) {
        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);
    }

利用集合c构建Vector

核心方法

copyInto(Object[] anArray)：

public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

下面方法都加了synchronized，保证线程安全 
elementData内元素复制到anArray中

trimToSize（）：

public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }

修剪elementData，保证其内部的元素都是有效元素 
elementCount 记录实际元素个数

ensureCapacity(int minCapacity)

public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);//是否需要增加容量
        }
    }

增加容量

ensureCapacityHelper(int minCapacity)

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

根据Vector长度和判断是否需要增加容量

grow(int 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;
    }

capacity()

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

获取当前Vector的容量

size（）

public synchronized int size() {
        return elementCount;
    }

获取当前Vector元素的个数

isEmpty（）

public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

判断是否为空

elements（）

public Enumeration<E> elements() {
        return new Enumeration<E>() {
            int count = 0;

            public boolean hasMoreElements() {
                return count < elementCount;
            }

            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }

获取一个Enumeration类型的组件，可以顺序的访问Vector元素，这个和迭代器很类似

contains(Object o)

public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }

判断是否包含元素 o

indexOf(Object o)

public int indexOf(Object o) {
        return indexOf(o, 0);
    }

返回元素 o 第一次出现的下标

indexOf(Object o, int index)

 public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

从index开始，查找元素o出现的下标 
当不出现的时候返回-1 
实现很简单顺序查找，比较是否相等

如有错误请留言或weixin：qiushuzhao222