Java 集合系列06之 Vector详细介绍(源码解析)和使用示例

http://www.cnblogs.com/skywang12345/p/3308833.html

概要

学完ArrayList和LinkedList之后，我们接着学习Vector。学习方式还是和之前一样，先对Vector有个整体认识，然后再学习它的源码；最后再通过实例来学会使用它。
第1部分 Vector介绍
 第2部分 Vector数据结构
 第3部分 Vector源码解析(基于JDK1.6.0_45)
第4部分 Vector遍历方式
 第5部分 Vector示例

转载请注明出处：http://www.cnblogs.com/skywang12345/p/3308833.html

第1部分 Vector介绍

Vector简介

Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。

和ArrayList不同，Vector中的操作是线程安全的。

Vector的构造函数

Vector共有4个构造函数
// 默认构造函数
Vector()

// capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
Vector(int capacity)

// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
Vector(int capacity, int capacityIncrement)

// 创建一个包含collection的Vector
Vector(Collection<? extends E> collection)

Vector的API

synchronized boolean        add(E object)
             void           add(int location, E object)
synchronized boolean        addAll(Collection<? extends E> collection)
synchronized boolean        addAll(int location, Collection<? extends E> collection)
synchronized void           addElement(E object)
synchronized int            capacity()
             void           clear()
synchronized Object         clone()
             boolean        contains(Object object)
synchronized boolean        containsAll(Collection<?> collection)
synchronized void           copyInto(Object[] elements)
synchronized E              elementAt(int location)
             Enumeration<E> elements()
synchronized void           ensureCapacity(int minimumCapacity)
synchronized boolean        equals(Object object)
synchronized E              firstElement()
             E              get(int location)
synchronized int            hashCode()
synchronized int            indexOf(Object object, int location)
             int            indexOf(Object object)
synchronized void           insertElementAt(E object, int location)
synchronized boolean        isEmpty()
synchronized E              lastElement()
synchronized int            lastIndexOf(Object object, int location)
synchronized int            lastIndexOf(Object object)
synchronized E              remove(int location)
             boolean        remove(Object object)
synchronized boolean        removeAll(Collection<?> collection)
synchronized void           removeAllElements()
synchronized boolean        removeElement(Object object)
synchronized void           removeElementAt(int location)
synchronized boolean        retainAll(Collection<?> collection)
synchronized E              set(int location, E object)
synchronized void           setElementAt(E object, int location)
synchronized void           setSize(int length)
synchronized int            size()
synchronized List<E>        subList(int start, int end)
synchronized <T> T[]        toArray(T[] contents)
synchronized Object[]       toArray()
synchronized String         toString()
synchronized void           trimToSize()

第2部分 Vector数据结构

Vector的继承关系

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.Vector<E>

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

Vector与Collection关系如下图：

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

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

(02) elementCount 是动态数组的实际大小。

(03) capacityIncrement 是动态数组的增长系数。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement。

第3部分 Vector源码解析(基于JDK1.6.0_45)

为了更了解Vector的原理，下面对Vector源码代码作出分析。

View Code

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

第4部分 Vector遍历方式

Vector支持4种遍历方式。建议使用下面的第二种去遍历Vector，因为效率问题。

(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。

Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
    value = (Integer)vec.get(i);        
}

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

Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
    value = (Integer)vec.get(i);        
}

(03) 第三种，另一种for循环。如下：

Integer value = null;
for (Integer integ:vec) {
    value = integ;
}

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

Integer value = null;
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
    value = (Integer)enu.nextElement();
}

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

 1 import java.util.*;
 2 
 3 /*
 4  * @desc Vector遍历方式和效率的测试程序。
 5  *
 6  * @author skywang
 7  */
 8 public class VectorRandomAccessTest {
 9 
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) ;
18     
19     }
20 
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         }
27 
28     }
29 
30     public static void iteratorThroughRandomAccess(List list) {
31 
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     }
42 
43     public static void iteratorThroughIterator(List list) {
44 
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     }
55 
56 
57     public static void iteratorThroughFor2(List list) {
58 
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     }
68 
69     public static void iteratorThroughEnumeration(Vector vec) {
70 
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 }

运行结果：

iteratorThroughRandomAccess：6 ms
iteratorThroughIterator：9 ms
iteratorThroughFor2：8 ms
iteratorThroughEnumeration：7 ms

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

第5部分 Vector示例

下面通过示例学习如何使用Vector

 1 import java.util.Vector;
 2 import java.util.List;
 3 import java.util.Iterator;
 4 import java.util.Enumeration;
 5 
 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();
15             
16         // 添加元素
17         vec.add("1");
18         vec.add("2");
19         vec.add("3");
20         vec.add("4");
21         vec.add("5");
22 
23         // 设置第一个元素为100
24         vec.set(0, "100");
25         // 将“500”插入到第3个位置
26         vec.add(2, "300");
27         System.out.println("vec:"+vec);
28 
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());
39 
40         // 获取Vector的大小
41         System.out.println("size:"+vec.size());
42         // 获取Vector的总的容量
43         System.out.println("capacity:"+vec.capacity());
44 
45         // 获取vector的“第2”到“第4”个元素
46         System.out.println("vec 2 to 4:"+vec.subList(1, 4));
47 
48         // 通过Enumeration遍历Vector
49         Enumeration enu = vec.elements();
50         while(enu.hasMoreElements())
51             System.out.println("nextElement():"+enu.nextElement());
52             
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);
59             
60         // 获取vec对应的String数组
61         String[] arr = (String[]) vec.toArray(new String[0]);
62         for (String str:arr)
63             System.out.println("str:"+str);
64 
65         // 清空Vector。clear()和removeAllElements()一样！
66         vec.clear();
67 //        vec.removeAllElements();
68 
69         // 判断Vector是否为空
70         System.out.println("vec.isEmpty():"+vec.isEmpty());
71     }   
72 }