Java中的Vector容器怎么用

这篇文章主要介绍了Java中的Vector容器怎么用，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

一、前言

知识补充：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    extends AbstractList    implements List, 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    extends AbstractList    implements List, 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 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 elements() {        return new Enumeration() {            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 v = (Vector) 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[] 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 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 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 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 listIterator(int index) {        if (index < 0 || index > elementCount)            throw new IndexOutOfBoundsException("Index: "+index);        return new ListItr(index);    }    public synchronized ListIterator listIterator() {        return new ListItr(0);    }    public synchronized Iterator iterator() {        return new Itr();    }    private class Itr implements Iterator {        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 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 {        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 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 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 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 c) {        final int expectedModCount = modCount;        Arrays.sort((E[]) elementData, 0, elementCount, c);        if (modCount != expectedModCount) {            throw new ConcurrentModificationException();        }        modCount++;    }    @Override    public Spliterator spliterator() {        return new VectorSpliterator<>(this, null, 0, -1, 0);    }    /** Similar to ArrayList Spliterator */    static final class VectorSpliterator implements Spliterator {        private final Vector 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 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 trySplit() {            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;            return (lo >= mid) ? null :                new VectorSpliterator(list, array, lo, index = mid,                                         expectedModCount);        }        @SuppressWarnings("unchecked")        public boolean tryAdvance(Consumer 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 action) {            int i, hi; // hoist accesses and checks from loop            Vector 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
2. 通过迭代器遍历。即通过Iterator去遍历
Integer value = null;Iterator 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 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 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");    }}
输出如下：
iteratorThroughRandomAccess：3 ms
iteratorThroughIterator：6 ms
iteratorThroughFor2：5 ms
iteratorThroughEnumeration：5 ms
所以：遍历Vector，使用索引的随机访问方式最快，使用迭代器最慢。
感谢你能够认真阅读完这篇文章，希望小编分享的"Java中的Vector容器怎么用"这篇文章对大家有帮助，同时也希望大家多多支持，关注行业资讯频道，更多相关知识等着你来学习!