Java-Vector

对于List接口这里还介绍一个它的实现类Vector，Vector 类可以实现可增长的对象数组。

一、Vector简介

        Vector可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。不过，Vector的大小是可以增加或者减小的，以便适应创建Vector后进行添加或者删除操作。

        Vector实现List接口，继承AbstractList类，所以我们可以将其看做队列，支持相关的添加、删除、修改、遍历等功能。

        Vector实现RandmoAccess接口，即提供了随机访问功能，提供提供快速访问功能。在Vector我们可以直接访问元素。

        Vector 实现了Cloneable接口，支持clone()方法，可以被克隆。

[java] view plaincopyprint?

1. public class Vector<E>  
2.     extends AbstractList<E>  
3.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable  

        Vector提供了四个构造函数：

[java] view plaincopyprint?

1. /** 
2.      * 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。 
3.      */  
4.      public Vector() {  
5.             this(10);  
6.      }  
7.       
8.     /** 
9.      * 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。 
10.      */  
11.     public Vector(Collection<? extends E> c) {  
12.         elementData = c.toArray();  
13.         elementCount = elementData.length;  
14.         // c.toArray might (incorrectly) not return Object[] (see 6260652)  
15.         if (elementData.getClass() != Object[].class)  
16.             elementData = Arrays.copyOf(elementData, elementCount,  
17.                     Object[].class);  
18.     }  
19.       
20.     /** 
21.      * 使用指定的初始容量和等于零的容量增量构造一个空向量。 
22.      */  
23.     public Vector(int initialCapacity) {  
24.         this(initialCapacity, 0);  
25.     }  
26.       
27.     /** 
28.      *  使用指定的初始容量和容量增量构造一个空的向量。 
29.      */  
30.     public Vector(int initialCapacity, int capacityIncrement) {  
31.         super();  
32.         if (initialCapacity < 0)  
33.             throw new IllegalArgumentException("Illegal Capacity: "+  
34.                                                initialCapacity);  
35.         this.elementData = new Object[initialCapacity];  
36.         this.capacityIncrement = capacityIncrement;  
37.     }  

        在成员变量方面，Vector提供了elementData , elementCount， capacityIncrement三个成员变量。其中

        elementData ："Object[]类型的数组"，它保存了Vector中的元素。按照Vector的设计elementData为一个动态数组，可以随着元素的增加而动态的增长，其具体的增加方式后面提到（ensureCapacity方法）。如果在初始化Vector时没有指定容器大小，则使用默认大小为10.

        elementCount：Vector 对象中的有效组件数。

        capacityIncrement：向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。

        同时Vector是线程安全的！

二、源码解析

        对于源码的解析，LZ在这里只就增加（add）删除（remove）两个方法进行讲解。

2.1增加：add(E e)

        add(E e)：将指定元素添加到此向量的末尾。

[java] view plaincopyprint?

1. public synchronized boolean add(E e) {  
2.         modCount++;       
3.         ensureCapacityHelper(elementCount + 1);    //确认容器大小，如果操作容量则扩容操作  
4.         elementData[elementCount++] = e;   //将e元素添加至末尾  
5.         return true;  
6.     }  

        这个方法相对而言比较简单，具体过程就是先确认容器的大小，看是否需要进行扩容操作，然后将E元素添加到此向量的末尾。

[java] view plaincopyprint?

1. private void ensureCapacityHelper(int minCapacity) {  
2.         //如果  
3.         if (minCapacity - elementData.length > 0)  
4.             grow(minCapacity);  
5.     }  
6.       
7.     /** 
8.      * 进行扩容操作 
9.      * 如果此向量的当前容量小于minCapacity，则通过将其内部数组替换为一个较大的数组俩增加其容量。 
10.      * 新数据数组的大小姜维原来的大小 + capacityIncrement， 
11.      * 除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，不过，如果此大小仍然小于 minCapacity，则新容量将为 minCapacity。 
12.      */  
13.     private void grow(int minCapacity) {  
14.         int oldCapacity = elementData.length;     //当前容器大小  
15.         /* 
16.          * 新容器大小 
17.          * 若容量增量系数(capacityIncrement) > 0，则将容器大小增加到capacityIncrement 
18.          * 否则将容量增加一倍 
19.          */  
20.         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
21.                                          capacityIncrement : oldCapacity);  
22.           
23.         if (newCapacity - minCapacity < 0)  
24.             newCapacity = minCapacity;  
25.           
26.         if (newCapacity - MAX_ARRAY_SIZE > 0)  
27.             newCapacity = hugeCapacity(minCapacity);  
28.           
29.         elementData = Arrays.copyOf(elementData, newCapacity);  
30.     }  
31.       
32.     /** 
33.      * 判断是否超出最大范围 
34.      * MAX_ARRAY_SIZE：private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; 
35.      */  
36.     private static int hugeCapacity(int minCapacity) {  
37.         if (minCapacity < 0)  
38.             throw new OutOfMemoryError();  
39.         return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;  
40.     }  

        对于Vector整个的扩容过程，就是根据capacityIncrement确认扩容大小的，若capacityIncrement <= 0 则扩大一倍，否则扩大至capacityIncrement 。当然这个容量的最大范围为Integer.MAX_VALUE即，2^32 - 1，所以Vector并不是可以无限扩充的。

2.2、remove(Object o)

[java] view plaincopyprint?

1. /** 
2.      * 从Vector容器中移除指定元素E 
3.      */  
4.     public boolean remove(Object o) {  
5.         return removeElement(o);  
6.     }  
7.   
8.     public synchronized boolean removeElement(Object obj) {  
9.         modCount++;  
10.         int i = indexOf(obj);   //计算obj在Vector容器中位置  
11.         if (i >= 0) {  
12.             removeElementAt(i);   //移除  
13.             return true;  
14.         }  
15.         return false;  
16.     }  
17.       
18.     public synchronized void removeElementAt(int index) {  
19.         modCount++;     //修改次数+1  
20.         if (index >= elementCount) {   //删除位置大于容器有效大小  
21.             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);  
22.         }  
23.         else if (index < 0) {    //位置小于 < 0  
24.             throw new ArrayIndexOutOfBoundsException(index);  
25.         }  
26.         int j = elementCount - index - 1;  
27.         if (j > 0) {     
28.             //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。  
29.             //也就是数组元素从j位置往前移  
30.             System.arraycopy(elementData, index + 1, elementData, index, j);  
31.         }  
32.         elementCount--;   //容器中有效组件个数 - 1  
33.         elementData[elementCount] = null;    //将向量的末尾位置设置为null  
34.     }  

        因为Vector底层是使用数组实现的，所以它的操作都是对数组进行操作，只不过其是可以随着元素的增加而动态的改变容量大小，其实现方法是是使用Arrays.copyOf方法将旧数据拷贝到一个新的大容量数组中。Vector的整个内部实现都比较简单，这里就不在重述了。

三、Vector遍历

        Vector支持4种遍历方式。

3.1、随机访问

        因为Vector实现了RandmoAccess接口，可以通过下标来进行随机访问。

[java] view plaincopyprint?

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

3.2、迭代器

[java] view plaincopyprint?

1. Iterator it = vec.iterator();  
2.     while(it.hasNext()){  
3.         value = it.next();  
4.         //do something  
5.     }  

3.2、for循环

[java] view plaincopyprint?

1. for(Integer value:vec){  
2.         //do something  
3.     }  

3.4、Enumeration循环

[java] view plaincopyprint?

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

——————————————————————————————————————————————————————————————————————————
--      原文出自：http://cmsblogs.com/?p=1180。尊重作者的成果，转载请注明出处！                            

--     个人站点：http://cmsblogs.com         

版权声明：本文为博主原创文章，未经博主允许不得转载。