Vector简介

  1. public class Vector<E>
  2.     extends AbstractList<E>
  3.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  4. {
  6. }
  • Vector 它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
  • Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
  • Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
  • Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
  • Vector的方法上都加了synchronized， 和ArrayList不同，Vector中的操作是线程安全的。

Vector详解 - 图1

Vector的构造函数

Vector共有4个构造函数

  1. // 默认构造函数
  2. Vector()
  4. // capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
  5. Vector(int capacity)
  7. // capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
  8. Vector(int capacity, int capacityIncrement)
  10. // 创建一个包含collection的Vector
  11. Vector(Collection<? extends E> collection)

Vector的数据结构

Vector的数据结构和ArrayList差不多，它包含了3个成员变量：elementData , elementCount， capacityIncrement。

  • elementData 是”Object[]类型的数组”，它保存了添加到Vector中的元素。elementData是个动态数组，如果初始化Vector时，没指定动态数组的大小，则使用默认大小10。随着Vector中元素的增加，Vector的容量也会动态增长，capacityIncrement是与容量增长相关的增长系数，具体的增长方式，请参考源码分析中的ensureCapacity()函数。
  • elementCount 是动态数组的实际大小。
  • capacityIncrement 是动态数组的增长系数。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时，增加的大小都是capacityIncrement。

vector源码解析

  1. package java.util;
  3. public class Vector<E>
  4.     extends AbstractList<E>
  5.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  6. {
  8.     // 保存Vector中数据的数组
  9.     protected Object[] elementData;
  11.     // 实际数据的数量
  12.     protected int elementCount;
  14.     // 容量增长系数
  15.     protected int capacityIncrement;
  17.     // Vector的序列版本号
  18.     private static final long serialVersionUID = -2767605614048989439L;
  20.     // Vector构造函数。默认容量是10。
  21.     public Vector() {
  22.         this(10);
  23.     }
  25.     // 指定Vector容量大小的构造函数
  26.     public Vector(int initialCapacity) {
  27.         this(initialCapacity, 0);
  28.     }
  30.     // 指定Vector"容量大小"和"增长系数"的构造函数
  31.     public Vector(int initialCapacity, int capacityIncrement) {
  32.         super();
  33.         if (initialCapacity < 0)
  34.             throw new IllegalArgumentException("Illegal Capacity: "+
  35.                                                initialCapacity);
  36.         // 新建一个数组，数组容量是initialCapacity
  37.         this.elementData = new Object[initialCapacity];
  38.         // 设置容量增长系数
  39.         this.capacityIncrement = capacityIncrement;
  40.     }
  42.     // 指定集合的Vector构造函数。
  43.     public Vector(Collection<? extends E> c) {
  44.         // 获取“集合(c)”的数组，并将其赋值给elementData
  45.         elementData = c.toArray();
  46.         // 设置数组长度
  47.         elementCount = elementData.length;
  48.         // c.toArray might (incorrectly) not return Object[] (see 6260652)
  49.         //传入的集合可能不是Object的，就拷贝放入Object数组中Object[].class
  50.         if (elementData.getClass() != Object[].class)
  51.             elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
  52.     }
  54.     // 将数组Vector的全部元素都拷贝到数组anArray中
  55.     public synchronized void copyInto(Object[] anArray) {
  56.         System.arraycopy(elementData, 0, anArray, 0, elementCount);
  57.     }
  59.     /*
  60.         第一个参数： 源数组
  61.         第二个参数： 源数组开始拷贝的位置
  62.         第三个参数： 目标数组
  63.         第四个参数： 目标数据存放拷贝来的元素的开始位置
  64.         第五个参数： 被拷贝的元素数量
  65.         public static native void arraycopy(Object src,  int  srcPos,
  66.                                         Object dest, int destPos,
  67.                                         int length);
  68.     */
  70.     // 将当前容量值设为 =实际元素个数
  71.     public synchronized void trimToSize() {
  72.         modCount++;
  73.         int oldCapacity = elementData.length;
  74.         if (elementCount < oldCapacity) {
  75.             elementData = Arrays.copyOf(elementData, elementCount);
  76.         }
  77.     }
  79.     // 确认“Vector容量”的帮助函数
  80.     private void ensureCapacityHelper(int minCapacity) {
  81.         int oldCapacity = elementData.length;
  82.         // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
  83.         // 若 容量增量系数>0(即capacityIncrement>0)，则将容量增大当capacityIncrement
  84.         // 否则，将容量增大一倍。
  85.         if (minCapacity > oldCapacity) {
  86.             Object[] oldData = elementData;
  87.             int newCapacity = (capacityIncrement > 0) ?
  88.                 (oldCapacity + capacityIncrement) : (oldCapacity * 2);
  89.             if (newCapacity < minCapacity) {
  90.                 newCapacity = minCapacity;
  91.             }
  92.             elementData = Arrays.copyOf(elementData, newCapacity);
  93.         }
  94.     }
  96.     // 确定Vector的容量。
  97.     public synchronized void ensureCapacity(int minCapacity) {
  98.         // 将Vector的改变统计数+1
  99.         modCount++;
  100.         ensureCapacityHelper(minCapacity);
  101.     }
  103.     // 设置容量值为 newSize
  104.     public synchronized void setSize(int newSize) {
  105.         modCount++;
  106.         if (newSize > elementCount) {
  107.             // 若 "newSize 大于 Vector容量"，则调整Vector的大小。
  108.             ensureCapacityHelper(newSize);
  109.         } else {
  110.             // 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null
  111.             for (int i = newSize ; i < elementCount ; i++) {
  112.                 elementData[i] = null;
  113.             }
  114.         }
  115.         elementCount = newSize;
  116.     }
  118.     // 返回“Vector的总的容量”
  119.     public synchronized int capacity() {
  120.         return elementData.length;
  121.     }
  123.     // 返回“Vector的实际大小”，即Vector中元素个数
  124.     public synchronized int size() {
  125.         return elementCount;
  126.     }
  128.     // 判断Vector是否为空
  129.     public synchronized boolean isEmpty() {
  130.         return elementCount == 0;
  131.     }
  133.     // 返回“Vector中全部元素对应的Enumeration”
  134.     public Enumeration<E> elements() {
  135.         // 通过匿名类实现Enumeration
  136.         return new Enumeration<E>() {
  137.             int count = 0;
  139.             // 是否存在下一个元素
  140.             public boolean hasMoreElements() {
  141.                 return count < elementCount;
  142.             }
  144.             // 获取下一个元素
  145.             public E nextElement() {
  146.                 synchronized (Vector.this) {
  147.                     if (count < elementCount) {
  148.                         return (E)elementData[count++];
  149.                     }
  150.                 }
  151.                 throw new NoSuchElementException("Vector Enumeration");
  152.             }
  153.         };
  154.     }
  156.     // 返回Vector中是否包含对象(o)
  157.     public boolean contains(Object o) {
  158.         return indexOf(o, 0) >= 0;
  159.     }
  162.     // 从index位置开始向后查找元素(o)。
  163.     // 若找到，则返回元素的索引值；否则，返回-1
  164.     public synchronized int indexOf(Object o, int index) {
  165.         if (o == null) {
  166.             // 若查找元素为null，则正向找出null元素，并返回它对应的序号
  167.             for (int i = index ; i < elementCount ; i++)
  168.             if (elementData[i]==null)
  169.                 return i;
  170.         } else {
  171.             // 若查找元素不为null，则正向找出该元素，并返回它对应的序号
  172.             for (int i = index ; i < elementCount ; i++)
  173.             if (o.equals(elementData[i]))
  174.                 return i;
  175.         }
  176.         return -1;
  177.     }
  179.     // 查找并返回元素(o)在Vector中的索引值
  180.     public int indexOf(Object o) {
  181.         return indexOf(o, 0);
  182.     }
  184.     // 从后向前查找元素(o)。并返回元素的索引
  185.     public synchronized int lastIndexOf(Object o) {
  186.         return lastIndexOf(o, elementCount-1);
  187.     }
  189.     // 从后向前查找元素(o)。开始位置是从前向后的第index个数；
  190.     // 若找到，则返回元素的“索引值”；否则，返回-1。
  191.     public synchronized int lastIndexOf(Object o, int index) {
  192.         if (index >= elementCount)
  193.             throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
  195.         if (o == null) {
  196.             // 若查找元素为null，则反向找出null元素，并返回它对应的序号
  197.             for (int i = index; i >= 0; i--)
  198.             if (elementData[i]==null)
  199.                 return i;
  200.         } else {
  201.             // 若查找元素不为null，则反向找出该元素，并返回它对应的序号
  202.             for (int i = index; i >= 0; i--)
  203.             if (o.equals(elementData[i]))
  204.                 return i;
  205.         }
  206.         return -1;
  207.     }
  209.     // 返回Vector中index位置的元素。
  210.     // 若index月结，则抛出异常
  211.     public synchronized E elementAt(int index) {
  212.         if (index >= elementCount) {
  213.             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
  214.         }
  216.         return (E)elementData[index];
  217.     }
  219.     // 获取Vector中的第一个元素。
  220.     // 若失败，则抛出异常！
  221.     public synchronized E firstElement() {
  222.         if (elementCount == 0) {
  223.             throw new NoSuchElementException();
  224.         }
  225.         return (E)elementData[0];
  226.     }
  228.     // 获取Vector中的最后一个元素。
  229.     // 若失败，则抛出异常！
  230.     public synchronized E lastElement() {
  231.         if (elementCount == 0) {
  232.             throw new NoSuchElementException();
  233.         }
  234.         return (E)elementData[elementCount - 1];
  235.     }
  237.     // 设置index位置的元素值为obj
  238.     public synchronized void setElementAt(E obj, int index) {
  239.         if (index >= elementCount) {
  240.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  241.                                  elementCount);
  242.         }
  243.         elementData[index] = obj;
  244.     }
  246.     // 删除index位置的元素
  247.     public synchronized void removeElementAt(int index) {
  248.         modCount++;
  249.         if (index >= elementCount) {
  250.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  251.                                  elementCount);
  252.         } else if (index < 0) {
  253.             throw new ArrayIndexOutOfBoundsException(index);
  254.         }
  256.         int j = elementCount - index - 1;
  257.         if (j > 0) {
  258.             System.arraycopy(elementData, index + 1, elementData, index, j);
  259.         }
  260.         elementCount--;
  261.         elementData[elementCount] = null; /* to let gc do its work */
  262.     }
  264.     // 在index位置处插入元素(obj)
  265.     public synchronized void insertElementAt(E obj, int index) {
  266.         modCount++;
  267.         if (index > elementCount) {
  268.             throw new ArrayIndexOutOfBoundsException(index
  269.                                  + " > " + elementCount);
  270.         }
  271.         ensureCapacityHelper(elementCount + 1);
  272.         System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
  273.         elementData[index] = obj;
  274.         elementCount++;
  275.     }
  277.     // 将“元素obj”添加到Vector末尾
  278.     public synchronized void addElement(E obj) {
  279.         modCount++; //记录操作次数
  280.         ensureCapacityHelper(elementCount + 1); // 确认内部数组长度
  281.         elementData[elementCount++] = obj;
  282.     }
  284.     // 在Vector中查找并删除元素obj。
  285.     // 成功的话，返回true；否则，返回false。
  286.     public synchronized boolean removeElement(Object obj) {
  287.         modCount++;
  288.         int i = indexOf(obj);
  289.         if (i >= 0) {
  290.             removeElementAt(i);
  291.             return true;
  292.         }
  293.         return false;
  294.     }
  296.     // 删除Vector中的全部元素
  297.     public synchronized void removeAllElements() {
  298.         modCount++;
  299.         // 将Vector中的全部元素设为null
  300.         for (int i = 0; i < elementCount; i++)
  301.             elementData[i] = null;
  303.         elementCount = 0;
  304.     }
  306.     // 克隆函数
  307.     public synchronized Object clone() {
  308.         try {
  309.             Vector<E> v = (Vector<E>) super.clone();
  310.             // 将当前Vector的全部元素拷贝到v中
  311.             v.elementData = Arrays.copyOf(elementData, elementCount);
  312.             v.modCount = 0;
  313.             return v;
  314.         } catch (CloneNotSupportedException e) {
  315.             // this shouldn't happen, since we are Cloneable
  316.             throw new InternalError();
  317.         }
  318.     }
  320.     // 返回Object数组
  321.     public synchronized Object[] toArray() {
  322.         return Arrays.copyOf(elementData, elementCount);
  323.     }
  325.     // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
  326.     public synchronized <T> T[] toArray(T[] a) {
  327.         // 若数组a的大小 < Vector的元素个数；
  328.         // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中
  329.         if (a.length < elementCount)
  330.             return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
  332.         // 若数组a的大小 >= Vector的元素个数；
  333.         // 则将Vector的全部元素都拷贝到数组a中。
  334.     System.arraycopy(elementData, 0, a, 0, elementCount);
  336.         if (a.length > elementCount)
  337.             a[elementCount] = null;
  339.         return a;
  340.     }
  342.     // 获取index位置的元素
  343.     public synchronized E get(int index) {
  344.         if (index >= elementCount)
  345.             throw new ArrayIndexOutOfBoundsException(index);
  347.         return (E)elementData[index];
  348.     }
  350.     // 设置index位置的值为element。并返回index位置的原始值
  351.     public synchronized E set(int index, E element) {
  352.         if (index >= elementCount)
  353.             throw new ArrayIndexOutOfBoundsException(index);
  355.         Object oldValue = elementData[index];
  356.         elementData[index] = element;
  357.         return (E)oldValue;
  358.     }
  360.     // 将“元素e”添加到Vector最后。
  361.     public synchronized boolean add(E e) {
  362.         modCount++;
  363.         ensureCapacityHelper(elementCount + 1);
  364.         elementData[elementCount++] = e;
  365.         return true;
  366.     }
  368.     // 删除Vector中的元素o
  369.     public boolean remove(Object o) {
  370.         return removeElement(o);
  371.     }
  373.     // 在index位置添加元素element
  374.     public void add(int index, E element) {
  375.         insertElementAt(element, index);
  376.     }
  378.     // 删除index位置的元素，并返回index位置的原始值
  379.     public synchronized E remove(int index) {
  380.         modCount++;
  381.         if (index >= elementCount)
  382.             throw new ArrayIndexOutOfBoundsException(index);
  383.         Object oldValue = elementData[index];
  385.         int numMoved = elementCount - index - 1;
  386.         if (numMoved > 0)
  387.             System.arraycopy(elementData, index+1, elementData, index,
  388.                      numMoved);
  389.         elementData[--elementCount] = null; // Let gc do its work
  391.         return (E)oldValue;
  392.     }
  394.     // 清空Vector
  395.     public void clear() {
  396.         removeAllElements();
  397.     }
  399.     // 返回Vector是否包含集合c
  400.     public synchronized boolean containsAll(Collection<?> c) {
  401.         return super.containsAll(c);
  402.     }
  404.     // 将集合c添加到Vector中
  405.     public synchronized boolean addAll(Collection<? extends E> c) {
  406.         modCount++;
  407.         Object[] a = c.toArray();
  408.         int numNew = a.length;
  409.         ensureCapacityHelper(elementCount + numNew);
  410.         // 将集合c的全部元素拷贝到数组elementData中
  411.         System.arraycopy(a, 0, elementData, elementCount, numNew);
  412.         elementCount += numNew;
  413.         return numNew != 0;
  414.     }
  416.     // 删除集合c的全部元素
  417.     public synchronized boolean removeAll(Collection<?> c) {
  418.         return super.removeAll(c);
  419.     }
  421.     // 删除“非集合c中的元素”
  422.     public synchronized boolean retainAll(Collection<?> c)  {
  423.         return super.retainAll(c);
  424.     }
  426.     // 从index位置开始，将集合c添加到Vector中
  427.     public synchronized boolean addAll(int index, Collection<? extends E> c) {
  428.         modCount++;
  429.         if (index < 0 || index > elementCount)
  430.             throw new ArrayIndexOutOfBoundsException(index);
  432.         Object[] a = c.toArray();
  433.         int numNew = a.length;
  434.         ensureCapacityHelper(elementCount + numNew);
  436.         int numMoved = elementCount - index;
  437.         if (numMoved > 0)
  438.         System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
  440.         System.arraycopy(a, 0, elementData, index, numNew);
  441.         elementCount += numNew;
  442.         return numNew != 0;
  443.     }
  445.     // 返回两个对象是否相等
  446.     public synchronized boolean equals(Object o) {
  447.         return super.equals(o);
  448.     }
  450.     // 计算哈希值
  451.     public synchronized int hashCode() {
  452.         return super.hashCode();
  453.     }
  455.     // 调用父类的toString()
  456.     public synchronized String toString() {
  457.         return super.toString();
  458.     }
  460.     // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集
  461.     public synchronized List<E> subList(int fromIndex, int toIndex) {
  462.         return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
  463.     }
  465.     // 删除Vector中fromIndex到toIndex的元素
  466.     protected synchronized void removeRange(int fromIndex, int toIndex) {
  467.         modCount++;
  468.         int numMoved = elementCount - toIndex;
  469.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  470.                          numMoved);
  472.         // Let gc do its work
  473.         int newElementCount = elementCount - (toIndex-fromIndex);
  474.         while (elementCount != newElementCount)
  475.             elementData[--elementCount] = null;
  476.     }
  478.     // java.io.Serializable的写入函数
  479.     private synchronized void writeObject(java.io.ObjectOutputStream s)
  480.         throws java.io.IOException {
  481.         s.defaultWriteObject();
  482.     }
  483. }
  1.    public synchronized boolean add(E e) {
  2.         modCount++;
  3.         ensureCapacityHelper(elementCount + 1); // 最小容量就是 原来的元素个数+新增的一个
  4.         elementData[elementCount++] = e;
  5.         return true;
  6.     }
  8.     private void ensureCapacityHelper(int minCapacity) {
  9.        // 如果需要的最小容量比数组的长度大就扩容
  10.         if (minCapacity - elementData.length > 0)
  11.             grow(minCapacity);
  12.     }
  14.     private void grow(int minCapacity) {
  15.         int oldCapacity = elementData.length; // 扩容前数组的长度
  16.         // 如果capacityIncrement大于零就扩容capacityIncrement，否则扩容1倍
  17.         int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
  18.         // 如果扩容后还是空间不够，就把minCapacity作为扩容后的数组长度
  19.         if (newCapacity - minCapacity < 0)
  20.             newCapacity = minCapacity;
  21.         // 判断扩容后的长度是不是超过了最大长度
  22.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  23.             newCapacity = hugeCapacity(minCapacity);
  24.         elementData = Arrays.copyOf(elementData, newCapacity);
  25.     }
  27.  /**
  28.      * The maximum size of array to allocate.
  29.      * Some VMs reserve some header words in an array.
  30.      * Attempts to allocate larger arrays may result in
  31.      * OutOfMemoryError: Requested array size exceeds VM limit
  32.      */
  33.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  36.     /*    最大值 2的31次方减1
  37.         最小值 2的31次方
  38.         System.out.println(Integer.MAX_VALUE + 1);  //-2147483648  
  39.         System.out.println(Integer.MIN_VALUE);      //-2147483648  
  40.     */
  41.     private static int hugeCapacity(int minCapacity) {
  42.             if (minCapacity < 0) // overflow
  43.                 throw new OutOfMemoryError();
  44.             return (minCapacity > MAX_ARRAY_SIZE) ?
  45.                 Integer.MAX_VALUE :
  46.                 MAX_ARRAY_SIZE;
  47.     }
  1.   // 删除index位置的元素
  2.     public synchronized void removeElementAt(int index) {
  3.         modCount++;
  4.         if (index >= elementCount) {
  5.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  6.                                  elementCount);
  7.         } else if (index < 0) {
  8.             throw new ArrayIndexOutOfBoundsException(index);
  9.         }
  11.         int j = elementCount - index - 1;
  12.         if (j > 0) {
  13.             System.arraycopy(elementData, index + 1, elementData, index, j);
  14.         }
  15.         elementCount--;
  16.         elementData[elementCount] = null; /* to let gc do its work */
  17.         // 注意这里把最后一个元素赋值为null
  18.     }

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

vector遍历方式

Vector支持4种遍历方式。建议使用下面的第二种去遍历Vector，因为效率问题。
第一种，通过迭代器遍历。即通过Iterator去遍历。

  1. Integer value = null;
  2. Iterator<int> size = vec.iterator();
  3. while(size.hasNext()){
  4.     value = size.next();
  5. }

(02) 第二种，随机访问，通过索引值去遍历。
由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素。

  1. Integer value = null;
  2. int size = vec.size();
  3. for (int i=0; i<size; i++) {
  4.     value = (Integer)vec.get(i);        
  5. }

(03) 第三种，增强for循环。如下：

  1. Integer value = null;
  2. for (Integer integ:vec) {
  3.     value = integ;
  4. }

(04) 第四种，Enumeration遍历。如下：

  1. Integer value = null;
  2. Enumeration enu = vec.elements();
  3. while (enu.hasMoreElements()) {
  4.     value = (Integer)enu.nextElement();
  5. }

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

  1. import java.util.*;
  3. /*
  4.  * @desc Vector遍历方式和效率的测试程序。
  5.  *
  6.  * @author skywang
  7.  */
  8. public class VectorRandomAccessTest {
  10.     public static void main(String[] args) {
  11.         Vector vec= new Vector();
  12.         for (int i=0; i<100000; i++)
  13.             vec.add(i);
  14.         iteratorThroughRandomAccess(vec) ;
  15.         iteratorThroughIterator(vec) ;
  16.         iteratorThroughFor2(vec) ;
  17.         iteratorThroughEnumeration(vec) ;
  19.     }
  21.     private static void isRandomAccessSupported(List list) {
  22.         if (list instanceof RandomAccess) {
  23.             System.out.println("RandomAccess implemented!");
  24.         } else {
  25.             System.out.println("RandomAccess not implemented!");
  26.         }
  28.     }
  30.     public static void iteratorThroughRandomAccess(List list) {
  32.         long startTime;
  33.         long endTime;
  34.         startTime = System.currentTimeMillis();
  35.         for (int i=0; i<list.size(); i++) {
  36.             list.get(i);
  37.         }
  38.         endTime = System.currentTimeMillis();
  39.         long interval = endTime - startTime;
  40.         System.out.println("iteratorThroughRandomAccess：" + interval+" ms");
  41.     }
  43.     public static void iteratorThroughIterator(List list) {
  45.         long startTime;
  46.         long endTime;
  47.         startTime = System.currentTimeMillis();
  48.         for(Iterator iter = list.iterator(); iter.hasNext(); ) {
  49.             iter.next();
  50.         }
  51.         endTime = System.currentTimeMillis();
  52.         long interval = endTime - startTime;
  53.         System.out.println("iteratorThroughIterator：" + interval+" ms");
  54.     }
  57.     public static void iteratorThroughFor2(List list) {
  59.         long startTime;
  60.         long endTime;
  61.         startTime = System.currentTimeMillis();
  62.         for(Object obj:list)
  63.             ;
  64.         endTime = System.currentTimeMillis();
  65.         long interval = endTime - startTime;
  66.         System.out.println("iteratorThroughFor2：" + interval+" ms");
  67.     }
  69.     public static void iteratorThroughEnumeration(Vector vec) {
  71.         long startTime;
  72.         long endTime;
  73.         startTime = System.currentTimeMillis();
  74.         for(Enumeration enu = vec.elements(); enu.hasMoreElements(); ) {
  75.             enu.nextElement();
  76.         }
  77.         endTime = System.currentTimeMillis();
  78.         long interval = endTime - startTime;
  79.         System.out.println("iteratorThroughEnumeration：" + interval+" ms");
  80.     }
  81. }

总结：遍历Vector，使用索引的随机访问方式最快，使用迭代器最慢。

vector实例

  1. import java.util.Vector;
  2. import java.util.List;
  3. import java.util.Iterator;
  4. import java.util.Enumeration;
  6. /**
  7.  * @desc Vector测试函数：遍历Vector和常用API 
  8.  *
  9.  * @author skywang
  10.  */
  11. public class VectorTest {
  12.     public static void main(String[] args) {
  13.         // 新建Vector
  14.         Vector vec = new Vector();
  16.         // 添加元素
  17.         vec.add("1");
  18.         vec.add("2");
  19.         vec.add("3");
  20.         vec.add("4");
  21.         vec.add("5");
  23.         // 设置第一个元素为100
  24.         vec.set(0, "100");
  25.         // 将“500”插入到第3个位置
  26.         vec.add(2, "300");
  27.         System.out.println("vec:"+vec);
  29.         // (顺序查找)获取100的索引
  30.         System.out.println("vec.indexOf(100):"+vec.indexOf("100"));
  31.         // (倒序查找)获取100的索引
  32.         System.out.println("vec.lastIndexOf(100):"+vec.lastIndexOf("100"));
  33.         // 获取第一个元素
  34.         System.out.println("vec.firstElement():"+vec.firstElement());
  35.         // 获取第3个元素
  36.         System.out.println("vec.elementAt(2):"+vec.elementAt(2));
  37.         // 获取最后一个元素
  38.         System.out.println("vec.lastElement():"+vec.lastElement());
  40.         // 获取Vector的大小
  41.         System.out.println("size:"+vec.size());
  42.         // 获取Vector的总的容量
  43.         System.out.println("capacity:"+vec.capacity());
  45.         // 获取vector的“第2”到“第4”个元素
  46.         System.out.println("vec 2 to 4:"+vec.subList(1, 4));
  48.         // 通过Enumeration遍历Vector
  49.         Enumeration enu = vec.elements();
  50.         while(enu.hasMoreElements())
  51.             System.out.println("nextElement():"+enu.nextElement());
  53.         Vector retainVec = new Vector();
  54.         retainVec.add("100");
  55.         retainVec.add("300");
  56.         // 获取“vec”中包含在“retainVec中的元素”的集合
  57.         System.out.println("vec.retain():"+vec.retainAll(retainVec));
  58.         System.out.println("vec:"+vec);
  60.         // 获取vec对应的String数组
  61.         String[] arr = (String[]) vec.toArray(new String[0]);
  62.         for (String str:arr)
  63.             System.out.println("str:"+str);
  65.         // 清空Vector。clear()和removeAllElements()一样！
  66.         vec.clear();
  67. //        vec.removeAllElements();
  69.         // 判断Vector是否为空
  70.         System.out.println("vec.isEmpty():"+vec.isEmpty());
  71.     }   
  72. }