Java基础之容器Vector详解_Java教程

一、前言

知识补充：Arrays.copyOf函数：

				?

									public static int[] copyOf(int[] original, int newLength) {  

									        int[] copy = new int[newLength];  

									        System.arraycopy(original, 0, copy, 0,  

									                         Math.min(original.length, newLength));  

									        return copy;  

									    }

可见copyOf()在内部新建一个数组，调用arrayCopy()将original内容复制到copy中去，并且长度为newLength。返回copy;

继续看一下System.arraycopy函数：

				?

									public static native void arraycopy(Object src,  int  srcPos,  

									                                        Object dest, int destPos,  

									                                        int length);

src - 源数组。

srcPos - 源数组中的起始位置。

dest - 目标数组。

destPos - 目标数据中的起始位置。

length - 要复制的数组元素的数量。

该方法是用了native关键字，调用的为C++编写的底层函数，可见其为JDK中的底层函数。

二、Vector简介

				?

									public class Vector<E>

									    extends AbstractList<E>

									    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector类实现了一个可增长的对象数组，内部是以动态数组的形式来存储数据的。
Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较低下。
继承了AbstractList,此类提供 List 接口的骨干实现，以最大限度地减少实现”随机访问”数据存储（如数组）支持的该接口所需的工作.对于连续的访问数据（如链表），应优先使用 AbstractSequentialList，而不是此类.
实现了List接口,意味着Vector元素是有序的,可以重复的,可以有null元素的集合.
实现了RandomAccess接口标识着其支持随机快速访问,实际上,我们查看RandomAccess源码可以看到,其实里面什么都没有定义.因为ArrayList底层是数组,那么随机快速访问是理所当然的,访问速度O(1).
实现了Cloneable接口,标识着可以它可以被复制.注意,ArrayList里面的clone()复制其实是浅复制
实现了Serializable 标识着集合可被序列化。

三、Vector源码

				?

									public class Vector<E>

									    extends AbstractList<E>

									    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

									{

									    //保存Vector数据的数组

									    protected Object[] elementData;

									    //实际数据的数量

									    protected int elementCount;

									    //容量增长的系数

									    protected int capacityIncrement;

									    // Vector的序列版本号

									    private static final long serialVersionUID = -2767605614048989439L;

									    //指定Vector初始大小和增长系数的构造函数

									    public Vector(int initialCapacity, int capacityIncrement) {

									        super();

									        if (initialCapacity < 0)

									            throw new IllegalArgumentException("Illegal Capacity: "+

									                                               initialCapacity);

									        this.elementData = new Object[initialCapacity];

									        this.capacityIncrement = capacityIncrement;

									    }

									    //指定初始容量的构造函数

									    public Vector(int initialCapacity) {

									        this(initialCapacity, 0);

									    }

									    //Vector构造函数，默认容量为10

									    public Vector() {

									        this(10);

									    }

									    //初始化一个指定集合数据的构造函数

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

									    }

									    //将Vector全部元素拷贝到anArray数组中

									    public synchronized void copyInto(Object[] anArray) {

									        System.arraycopy(elementData, 0, anArray, 0, elementCount);

									    }

									    //当前的数组中元素个数大于记录的元素个数时，重新赋值给当前数组所记录的元素

									    public synchronized void trimToSize() {

									        modCount++;

									        int oldCapacity = elementData.length;

									        if (elementCount < oldCapacity) {

									            elementData = Arrays.copyOf(elementData, elementCount);

									        }

									    }

									   //确定Vector的容量

									    public synchronized void ensureCapacity(int minCapacity) {

									        if (minCapacity > 0) {

									            // 将Vector的改变统计数+1

									            modCount++;

									            ensureCapacityHelper(minCapacity);

									        }

									    }

									    //确定容量的帮助函数，如果所需容量大于当前的容量时则执行扩容

									    private void ensureCapacityHelper(int minCapacity) {

									        // overflow-conscious code

									        if (minCapacity - elementData.length > 0)

									            grow(minCapacity);

									    }

									    //数组所允许的最大容量

									    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

									    //执行扩容函数

									    private void grow(int minCapacity) {

									        // overflow-conscious code

									        //记录当前容量

									        int oldCapacity = elementData.length;

									        //如果扩容系数大于0则新容量等于当前容量+扩容系数，如果扩容系数小于等于0则新容量等于当前容量的2倍

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

									    }

									    //巨大扩容函数，如果所需容量大于最大数组容量，则返回int形最大值(2^31 -1),否则返回最大数组容量

									    private static int hugeCapacity(int minCapacity) {

									        if (minCapacity < 0) // overflow

									            throw new OutOfMemoryError();

									        return (minCapacity > MAX_ARRAY_SIZE) ?

									            Integer.MAX_VALUE :

									            MAX_ARRAY_SIZE;

									    }

									    //设置容量值为newSize，如果newSize大于当前容量，则扩容，否则newSize以后的所有元素置null

									    public synchronized void setSize(int newSize) {

									        modCount++;

									        if (newSize > elementCount) {

									            ensureCapacityHelper(newSize);

									        } else {

									            for (int i = newSize ; i < elementCount ; i++) {

									                elementData[i] = null;

									            }

									        }

									        elementCount = newSize;

									    }

									    //返回当前Vector的容量

									    public synchronized int capacity() {

									        return elementData.length;

									    }

									    //返回Vector元素的个数

									    public synchronized int size() {

									        return elementCount;

									    }

									    //Vector元素个数是否为0

									    public synchronized boolean isEmpty() {

									        return elementCount == 0;

									    }

									    //返回Vector元素的Enumeration，Enumeration 接口是Iterator迭代器的“古老版本”

									    //Enumeration接口中的方法名称难以记忆，而且没有Iterator的remove()方法。如果现在编写Java程序，应该尽量采用

									    //Iterator迭代器，而不是用Enumeration迭代器。

									    //之所以保留Enumeration接口的原因，主要为了照顾以前那些“古老”的程序，那些程序里大量使用Enumeration接口，如果新版

									    //本的Java里直接删除Enumeration接口，将会导致那些程序全部出错。

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

									            }

									        };

									    }

									    //返回Vector中是否包含对象o

									    public boolean contains(Object o) {

									        return indexOf(o, 0) >= 0;

									    }

									    // 查找并返回元素(o)在Vector中的索引值

									    public int indexOf(Object o) {

									        return indexOf(o, 0);

									    }

									    // 从index位置开始向后查找元素(o)。

									    // 若找到，则返回元素的索引值；否则，返回-1

									    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;

									    }

									    // 从后向前查找元素(o)。并返回元素的索引

									    public synchronized int lastIndexOf(Object o) {

									        return lastIndexOf(o, elementCount-1);

									    }

									    // 从index位置开始向前查找元素(o)。

									    // 若找到，则返回元素的索引值；否则，返回-1

									    public synchronized int lastIndexOf(Object o, int index) {

									        if (index >= elementCount)

									            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);

									        if (o == null) {

									            for (int i = index; i >= 0; i--)

									                if (elementData[i]==null)

									                    return i;

									        } else {

									            for (int i = index; i >= 0; i--)

									                if (o.equals(elementData[i]))

									                    return i;

									        }

									        return -1;

									    }

									    // 返回Vector中index位置的元素。

									    // 若index越界，则抛出异常

									    public synchronized E elementAt(int index) {

									        if (index >= elementCount) {

									            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);

									        }

									        return elementData(index);

									    }

									    // 返回Vector中第0位置的元素。

									    public synchronized E firstElement() {

									        if (elementCount == 0) {

									            throw new NoSuchElementException();

									        }

									        return elementData(0);

									    }

									    // 返回Vector中最后一个元素。

									    public synchronized E lastElement() {

									        if (elementCount == 0) {

									            throw new NoSuchElementException();

									        }

									        return elementData(elementCount - 1);

									    }

									    // 设置index位置的元素值为obj

									    public synchronized void setElementAt(E obj, int index) {

									        if (index >= elementCount) {

									            throw new ArrayIndexOutOfBoundsException(index + " >= " +

									                                                     elementCount);

									        }

									        elementData[index] = obj;

									    }

									    //删除index位置处的元素

									    public synchronized void removeElementAt(int index) {

									        modCount++;

									        if (index >= elementCount) {

									            throw new ArrayIndexOutOfBoundsException(index + " >= " +

									                                                     elementCount);

									        }

									        else if (index < 0) {

									            throw new ArrayIndexOutOfBoundsException(index);

									        }

									        int j = elementCount - index - 1;

									        if (j > 0) {

									            System.arraycopy(elementData, index + 1, elementData, index, j);

									        }

									        elementCount--;

									        elementData[elementCount] = null; /* to let gc do its work */

									    }

									    //在index位置插入元素obj

									    public synchronized void insertElementAt(E obj, int index) {

									        modCount++;

									        if (index > elementCount) {

									            throw new ArrayIndexOutOfBoundsException(index

									                                                     + " > " + elementCount);

									        }

									        ensureCapacityHelper(elementCount + 1);

									        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);

									        elementData[index] = obj;

									        elementCount++;

									    }

									    //在vector后面添加对象obj

									    public synchronized void addElement(E obj) {

									        modCount++;

									        ensureCapacityHelper(elementCount + 1);

									        elementData[elementCount++] = obj;

									    }

									    // 在Vector中查找并删除元素obj。

									    // 成功的话，返回true；否则，返回false。

									    public synchronized boolean removeElement(Object obj) {

									        modCount++;

									        int i = indexOf(obj);

									        if (i >= 0) {

									            removeElementAt(i);

									            return true;

									        }

									        return false;

									    }

									    //删除Vector中所有元素

									    public synchronized void removeAllElements() {

									        modCount++;

									        // Let gc do its work

									        for (int i = 0; i < elementCount; i++)

									            elementData[i] = null;

									        elementCount = 0;

									    }

									    //返回Vector的克隆。 该副本将包含对内部数据数组的克隆的引用，而不是对此对象的原始内部数据数组的引用。

									    public synchronized Object clone() {

									        try {

									            @SuppressWarnings("unchecked")

									                Vector<E> v = (Vector<E>) super.clone();

									            v.elementData = Arrays.copyOf(elementData, elementCount);

									            v.modCount = 0;

									            return v;

									        } catch (CloneNotSupportedException e) {

									            // this shouldn't happen, since we are Cloneable

									            throw new InternalError(e);

									        }

									    }

									    //返回包含Vector所有元素的数组

									    public synchronized Object[] toArray() {

									        return Arrays.copyOf(elementData, elementCount);

									    }

									    // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型

									    @SuppressWarnings("unchecked")

									    public synchronized <T> T[] toArray(T[] a) {

									        // 若数组a的大小 < Vector的元素个数；

									        // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中

									        if (a.length < elementCount)

									            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

									        // 若数组a的大小 >= Vector的元素个数；

									        // 则将Vector的全部元素都拷贝到数组a中。

									        System.arraycopy(elementData, 0, a, 0, elementCount);

									        if (a.length > elementCount)

									            a[elementCount] = null;

									        return a;

									    }

									    // Positional Access Operations

									    @SuppressWarnings("unchecked")

									    E elementData(int index) {

									        return (E) elementData[index];

									    }

									    //获取index处的元素

									    public synchronized E get(int index) {

									        if (index >= elementCount)

									            throw new ArrayIndexOutOfBoundsException(index);

									        return elementData(index);

									    }

									    //设置index处的元素为element，并返回被替换掉的元素

									    public synchronized E set(int index, E element) {

									        if (index >= elementCount)

									            throw new ArrayIndexOutOfBoundsException(index);

									        E oldValue = elementData(index);

									        elementData[index] = element;

									        return oldValue;

									    }

									    //Vector末尾添加元素

									    public synchronized boolean add(E e) {

									        modCount++;

									        ensureCapacityHelper(elementCount + 1);

									        elementData[elementCount++] = e;

									        return true;

									    }

									    //移除Vector中第一个出现对象o的元素

									    public boolean remove(Object o) {

									        return removeElement(o);

									    }

									    //在index位置添加对象element

									    public void add(int index, E element) {

									        insertElementAt(element, index);

									    }

									    //移除index位置的元素

									    public synchronized E remove(int index) {

									        modCount++;

									        if (index >= elementCount)

									            throw new ArrayIndexOutOfBoundsException(index);

									        E oldValue = elementData(index);

									        int numMoved = elementCount - index - 1;

									        if (numMoved > 0)

									            System.arraycopy(elementData, index+1, elementData, index,

									                             numMoved);

									        elementData[--elementCount] = null; // Let gc do its work

									        return oldValue;

									    }

									    // 清空Vector

									    public void clear() {

									        removeAllElements();

									    }

									    // Bulk Operations

									    // 返回Vector是否包含集合c

									    public synchronized boolean containsAll(Collection<?> c) {

									        return super.containsAll(c);

									    }

									    //在Vector末尾添加集合c

									    public synchronized boolean addAll(Collection<? extends E> c) {

									        modCount++;

									        Object[] a = c.toArray();

									        int numNew = a.length;

									        ensureCapacityHelper(elementCount + numNew);

									        System.arraycopy(a, 0, elementData, elementCount, numNew);

									        elementCount += numNew;

									        return numNew != 0;

									    }

									    // 删除集合c的全部元素

									    public synchronized boolean removeAll(Collection<?> c) {

									        return super.removeAll(c);

									    }

									    // 删除“非集合c中的元素”

									    public synchronized boolean retainAll(Collection<?> c) {

									        return super.retainAll(c);

									    }

									   //在index位置添加集合c中的元素

									    public synchronized boolean addAll(int index, Collection<? extends E> c) {

									        modCount++;

									        if (index < 0 || index > elementCount)

									            throw new ArrayIndexOutOfBoundsException(index);

									        Object[] a = c.toArray();

									        int numNew = a.length;

									        ensureCapacityHelper(elementCount + numNew);

									        int numMoved = elementCount - index;

									        if (numMoved > 0)

									            System.arraycopy(elementData, index, elementData, index + numNew,

									                             numMoved);

									        System.arraycopy(a, 0, elementData, index, numNew);

									        elementCount += numNew;

									        return numNew != 0;

									    }

									    // 返回两个对象是否相等

									    public synchronized boolean equals(Object o) {

									        return super.equals(o);

									    }

									   // 计算哈希值

									    public synchronized int hashCode() {

									        return super.hashCode();

									    }

									    // 调用父类的toString()

									    public synchronized String toString() {

									        return super.toString();

									    }

									    // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集

									    public synchronized List<E> subList(int fromIndex, int toIndex) {

									        return Collections.synchronizedList(super.subList(fromIndex, toIndex),

									                                            this);

									    }

									    // 删除Vector中fromIndex到toIndex的元素

									    protected synchronized void removeRange(int fromIndex, int toIndex) {

									        modCount++;

									        int numMoved = elementCount - toIndex;

									        System.arraycopy(elementData, toIndex, elementData, fromIndex,

									                         numMoved);

									        // Let gc do its work

									        int newElementCount = elementCount - (toIndex-fromIndex);

									        while (elementCount != newElementCount)

									            elementData[--elementCount] = null;

									    }

									    // java.io.Serializable的写入函数

									    private void writeObject(java.io.ObjectOutputStream s)

									            throws java.io.IOException {

									        final java.io.ObjectOutputStream.PutField fields = s.putFields();

									        final Object[] data;

									        synchronized (this) {

									            fields.put("capacityIncrement", capacityIncrement);

									            fields.put("elementCount", elementCount);

									            data = elementData.clone();

									        }

									        fields.put("elementData", data);

									        s.writeFields();

									    }

									    public synchronized ListIterator<E> listIterator(int index) {

									        if (index < 0 || index > elementCount)

									            throw new IndexOutOfBoundsException("Index: "+index);

									        return new ListItr(index);

									    }

									    public synchronized ListIterator<E> listIterator() {

									        return new ListItr(0);

									    }

									    public synchronized Iterator<E> iterator() {

									        return new Itr();

									    }

									    private class Itr implements Iterator<E> {

									        int cursor;       // index of next element to return

									        int lastRet = -1; // index of last element returned; -1 if no such

									        int expectedModCount = modCount;

									        public boolean hasNext() {

									            // Racy but within spec, since modifications are checked

									            // within or after synchronization in next/previous

									            return cursor != elementCount;

									        }

									        public E next() {

									            synchronized (Vector.this) {

									                checkForComodification();

									                int i = cursor;

									                if (i >= elementCount)

									                    throw new NoSuchElementException();

									                cursor = i + 1;

									                return elementData(lastRet = i);

									            }

									        }

									        public void remove() {

									            if (lastRet == -1)

									                throw new IllegalStateException();

									            synchronized (Vector.this) {

									                checkForComodification();

									                Vector.this.remove(lastRet);

									                expectedModCount = modCount;

									            }

									            cursor = lastRet;

									            lastRet = -1;

									        }

									        @Override

									        public void forEachRemaining(Consumer<? super E> action) {

									            Objects.requireNonNull(action);

									            synchronized (Vector.this) {

									                final int size = elementCount;

									                int i = cursor;

									                if (i >= size) {

									                    return;

									                }

									        @SuppressWarnings("unchecked")

									                final E[] elementData = (E[]) Vector.this.elementData;

									                if (i >= elementData.length) {

									                    throw new ConcurrentModificationException();

									                }

									                while (i != size && modCount == expectedModCount) {

									                    action.accept(elementData[i++]);

									                }

									                // update once at end of iteration to reduce heap write traffic

									                cursor = i;

									                lastRet = i - 1;

									                checkForComodification();

									            }

									        }

									        final void checkForComodification() {

									            if (modCount != expectedModCount)

									                throw new ConcurrentModificationException();

									        }

									    }

									    final class ListItr extends Itr implements ListIterator<E> {

									        ListItr(int index) {

									            super();

									            cursor = index;

									        }

									        public boolean hasPrevious() {

									            return cursor != 0;

									        }

									        public int nextIndex() {

									            return cursor;

									        }

									        public int previousIndex() {

									            return cursor - 1;

									        }

									        public E previous() {

									            synchronized (Vector.this) {

									                checkForComodification();

									                int i = cursor - 1;

									                if (i < 0)

									                    throw new NoSuchElementException();

									                cursor = i;

									                return elementData(lastRet = i);

									            }

									        }

									        public void set(E e) {

									            if (lastRet == -1)

									                throw new IllegalStateException();

									            synchronized (Vector.this) {

									                checkForComodification();

									                Vector.this.set(lastRet, e);

									            }

									        }

									        public void add(E e) {

									            int i = cursor;

									            synchronized (Vector.this) {

									                checkForComodification();

									                Vector.this.add(i, e);

									                expectedModCount = modCount;

									            }

									            cursor = i + 1;

									            lastRet = -1;

									        }

									    }

									    @Override

									    public synchronized void forEach(Consumer<? super E> action) {

									        Objects.requireNonNull(action);

									        final int expectedModCount = modCount;

									        @SuppressWarnings("unchecked")

									        final E[] elementData = (E[]) this.elementData;

									        final int elementCount = this.elementCount;

									        for (int i=0; modCount == expectedModCount && i < elementCount; i++) {

									            action.accept(elementData[i]);

									        }

									        if (modCount != expectedModCount) {

									            throw new ConcurrentModificationException();

									        }

									    }

									    @Override

									    @SuppressWarnings("unchecked")

									    public synchronized boolean removeIf(Predicate<? super E> filter) {

									        Objects.requireNonNull(filter);

									        // figure out which elements are to be removed

									        // any exception thrown from the filter predicate at this stage

									        // will leave the collection unmodified

									        int removeCount = 0;

									        final int size = elementCount;

									        final BitSet removeSet = new BitSet(size);

									        final int expectedModCount = modCount;

									        for (int i=0; modCount == expectedModCount && i < size; i++) {

									            @SuppressWarnings("unchecked")

									            final E element = (E) elementData[i];

									            if (filter.test(element)) {

									                removeSet.set(i);

									                removeCount++;

									            }

									        }

									        if (modCount != expectedModCount) {

									            throw new ConcurrentModificationException();

									        }

									        // shift surviving elements left over the spaces left by removed elements

									        final boolean anyToRemove = removeCount > 0;

									        if (anyToRemove) {

									            final int newSize = size - removeCount;

									            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {

									                i = removeSet.nextClearBit(i);

									                elementData[j] = elementData[i];

									            }

									            for (int k=newSize; k < size; k++) {

									                elementData[k] = null;  // Let gc do its work

									            }

									            elementCount = newSize;

									            if (modCount != expectedModCount) {

									                throw new ConcurrentModificationException();

									            }

									            modCount++;

									        }

									        return anyToRemove;

									    }

									    @Override

									    @SuppressWarnings("unchecked")

									    public synchronized void replaceAll(UnaryOperator<E> operator) {

									        Objects.requireNonNull(operator);

									        final int expectedModCount = modCount;

									        final int size = elementCount;

									        for (int i=0; modCount == expectedModCount && i < size; i++) {

									            elementData[i] = operator.apply((E) elementData[i]);

									        }

									        if (modCount != expectedModCount) {

									            throw new ConcurrentModificationException();

									        }

									        modCount++;

									    }

									    @SuppressWarnings("unchecked")

									    @Override

									    public synchronized void sort(Comparator<? super E> c) {

									        final int expectedModCount = modCount;

									        Arrays.sort((E[]) elementData, 0, elementCount, c);

									        if (modCount != expectedModCount) {

									            throw new ConcurrentModificationException();

									        }

									        modCount++;

									    }

									    @Override

									    public Spliterator<E> spliterator() {

									        return new VectorSpliterator<>(this, null, 0, -1, 0);

									    }

									    /** Similar to ArrayList Spliterator */

									    static final class VectorSpliterator<E> implements Spliterator<E> {

									        private final Vector<E> list;

									        private Object[] array;

									        private int index; // current index, modified on advance/split

									        private int fence; // -1 until used; then one past last index

									        private int expectedModCount; // initialized when fence set

									        /** Create new spliterator covering the given  range */

									        VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,

									                          int expectedModCount) {

									            this.list = list;

									            this.array = array;

									            this.index = origin;

									            this.fence = fence;

									            this.expectedModCount = expectedModCount;

									        }

									        private int getFence() { // initialize on first use

									            int hi;

									            if ((hi = fence) < 0) {

									                synchronized(list) {

									                    array = list.elementData;

									                    expectedModCount = list.modCount;

									                    hi = fence = list.elementCount;

									                }

									            }

									            return hi;

									        }

									        public Spliterator<E> trySplit() {

									            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;

									            return (lo >= mid) ? null :

									                new VectorSpliterator<E>(list, array, lo, index = mid,

									                                         expectedModCount);

									        }

									        @SuppressWarnings("unchecked")

									        public boolean tryAdvance(Consumer<? super E> action) {

									            int i;

									            if (action == null)

									                throw new NullPointerException();

									            if (getFence() > (i = index)) {

									                index = i + 1;

									                action.accept((E)array[i]);

									                if (list.modCount != expectedModCount)

									                    throw new ConcurrentModificationException();

									                return true;

									            }

									            return false;

									        }

									        @SuppressWarnings("unchecked")

									        public void forEachRemaining(Consumer<? super E> action) {

									            int i, hi; // hoist accesses and checks from loop

									            Vector<E> lst; Object[] a;

									            if (action == null)

									                throw new NullPointerException();

									            if ((lst = list) != null) {

									                if ((hi = fence) < 0) {

									                    synchronized(lst) {

									                        expectedModCount = lst.modCount;

									                        a = array = lst.elementData;

									                        hi = fence = lst.elementCount;

									                    }

									                }

									                else

									                    a = array;

									                if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {

									                    while (i < hi)

									                        action.accept((E) a[i++]);

									                    if (lst.modCount == expectedModCount)

									                        return;

									                }

									            }

									            throw new ConcurrentModificationException();

									        }

									        public long estimateSize() {

									            return (long) (getFence() - index);

									        }

									        public int characteristics() {

									            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;

									        }

									    }

									}

四、总结

Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若使用默认构造函数，则Vector的默认容量大小是10。
当Vector容量不足以容纳全部元素时，Vector的容量会增加。若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。
Vector的克隆函数，即是将全部元素克隆到一个数组中。

五、Vector遍历方式

1. 随机访问遍历，通过索引值去遍历

由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素。

				?

									Integer value = null;

									int size = vec.size();

									for (int i=0; i<size; i++) {

									    value = (Integer)vec.get(i);        

									}

2. 通过迭代器遍历。即通过Iterator去遍历

				?

									Integer value = null;

									Iterator<Integer> iterator = vec.iterator();

									   while (iterator.hasNext()) {

									       value = iterator.next();

									   }

3. 通过增强for循环去遍历

				?

									Integer value = null;

									for (Integer integ:vec) {

									    value = integ;

									}

4. 通过Enumeration遍历

				?

									Integer value = null;

									Enumeration enu = vec.elements();

									while (enu.hasMoreElements()) {

									    value = (Integer)enu.nextElement();

									}

测试这些遍历方式效率的代码如下：

				?

									public class Test {

									    public static void main(String[] args) {

									        Vector<Integer> vector = new Vector<>();

									        for (int i = 0; i < 100000; i++)

									            vector.add(i);

									        iteratorThroughRandomAccess(vector);

									        iteratorThroughIterator(vector);

									        iteratorThroughFor2(vector);

									        iteratorThroughEnumeration(vector);

									    }

									    public static void iteratorThroughRandomAccess(List list) {

									        long startTime, endTime;

									        startTime = System.currentTimeMillis();

									        for (int i = 0; i < list.size(); i++) {

									        }

									        endTime = System.currentTimeMillis();

									        long time = endTime - startTime;

									        System.out.println("iteratorThroughRandomAccess：" + time + " ms");

									    }

									    public static void iteratorThroughIterator(List list) {

									        long startTime, endTime;

									        startTime = System.currentTimeMillis();

									        Iterator<Integer> iterator = list.iterator();

									        while (iterator.hasNext()) {

									            iterator.next();

									        }

									        endTime = System.currentTimeMillis();

									        long time = endTime - startTime;

									        System.out.println("iteratorThroughIterator：" + time + " ms");

									    }

									    public static void iteratorThroughFor2(List list) {

									        long startTime, endTime;

									        startTime = System.currentTimeMillis();

									        for (Object o : list) {

									        }

									        endTime = System.currentTimeMillis();

									        long time = endTime - startTime;

									        System.out.println("iteratorThroughFor2：" + time + " ms");

									    }

									    public static void iteratorThroughEnumeration(Vector vec) {

									        long startTime, endTime;

									        startTime = System.currentTimeMillis();

									        for (Enumeration enu = vec.elements(); enu.hasMoreElements(); ) {

									            enu.nextElement();

									        }

									        endTime = System.currentTimeMillis();

									        long time = endTime - startTime;

									        System.out.println("iteratorThroughEnumeration：" + time + " ms");

									    }

									}