Vector和ArrayList异同

一、Vector

Vector也是一个类似于ArrayList的可变长度的数组类型，它的内部也是使用数组来存放数据对象的。值得注意的是Vector与ArrayList唯一的区别是，Vector是线程安全的，即它的大部分方法都包含有关键字synchronized，因此，若对于单一线程的应用来说，最好使用ArrayList代替Vector，因为这样效率会快很多（类似的情况有StringBuffer与StringBuilder）；而在多线程程序中，为了保证数据的同步和一致性，可以使用Vector代替ArrayList实现同样的功能。

二、ArrayList

ArrayList是一个可以处理变长数组的类型，这里不局限于“数”组，ArrayList是一个泛型类，可以存放任意类型的对象。顾名思义，ArrayList是一个数组列表，因此其内部是使用一个数组来存放对象的，因为Object是一切类型的父类，因而ArrayList内部是有一个Object类型的数组类存放对象。ArrayList类常用的方法有add()、clear()、get()、indexOf()、remove()、sort()、toArray()、toString()等等，同时ArrayList内部有一个私有类实现Iterator接口，因此可以使用iterator()方法得到ArrayList的迭代器，同时，还有一个私有类实现了ListIterator接口，因此ArrayList也可以调用listIterator()方法得到ListIterator迭代器。

由于ArrayList是依靠数组来存放对象的，只不过封装起来了而已，因此其一些查找方法的效率都是O(n)，跟普通的数组效率差不多，只不过这个ArrayList是一个可变”数组“，并且可以存放一切指定的对象。

另外，由于ArrayList的所有方法都是默认在单一线程下进行的，因此ArrayList不具有线程安全性。若想在多线程下使用，应该使用Colletions类中的静态方法synchronizedList()对ArrayList进行调用即可。

//相同点

(1)

ArrayList和Vector都有一个初始的容量大小，当存储的空间不够时，需要增加存储空间，Vector默认增长原来的一倍，而ArrayList是原来的0.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小。

//不同点

1、Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

2、Vector可以设置增长因子，而ArrayList不可以，先看看两个类的构造方法：

ArrayList有三个构造方法：分别是

[java]  view plain  copy

1. public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。  
2. public ArrayList()//构造一个初始容量为10的空列表。  
3. public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表  

Vector有四个构造方法：

[java]  view plain  copy

1. public Vector()//使用指定的初始容量和等于零的容量增量构造一个空向量。  
2. public Vector(int initialCapacity)//构造一个空向量，使其内部数据数组的大小，其标准容量增量为零。  
3. public Vector(Collection<? extends E> c)//构造一个包含指定 collection 中的元素的向量  
4. public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量  

ArrayList类：

[java]  view plain  copy

1. public boolean add(E e) {  
2.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
3.     elementData[size++] = e;  
4.     return true;  
5. }  
6.   
7. private void ensureCapacityInternal(int minCapacity) {  
8.     modCount++;  
9.     // overflow-conscious code  
10.   
11.     //如果添加一个元素之后，新容器的大小大于容器的容量，那么就无法存值了，需要扩充空间  
12.     if (minCapacity - elementData.length > 0)  
13.   
14.         grow(minCapacity);  
15. }  
16.   
17. private void grow(int minCapacity) {  
18.     // overflow-conscious code  
19.     int oldCapacity = elementData.length;  
20.     int newCapacity = oldCapacity + (oldCapacity >> 1); //扩充的空间增加原来的50%（即是原来的1.5倍）  
21.     if (newCapacity - minCapacity < 0) //如果容器扩容之后还是不够，那么干脆直接将minCapacity设为容器的大小  
22.         newCapacity = minCapacity;  
23.     if (newCapacity - MAX_ARRAY_SIZE > 0) //如果扩充的容器太大了的话，那么就执行hugeCapacity  
24.         newCapacity = hugeCapacity(minCapacity);  
25.     // minCapacity is usually close to size, so this is a win:  
26.     elementData = Arrays.copyOf(elementData, newCapacity);  
27. }  
28.   
29.  //jdk1.6版本是这样的：  
30.   
31.  public void ensureCapacity(int minCapacity) {  
32.       modCount++;  
33.       int oldCapacity = elementData.length;  
34.       if (minCapacity > oldCapacity) {  
35.            Object oldData[] = elementData;  
36.            int newCapacity = (oldCapacity * 3) / 2 + 1;  
37.            if (newCapacity < minCapacity)  
38.                 newCapacity = minCapacity;  
39.            // minCapacity is usually close to size, so this is a win:  
40.            elementData = Arrays.copyOf(elementData, newCapacity);  
41.       }  
42.  }  

Vector类：

[java]  view plain  copy

1.  public synchronized boolean add(E e) {  
2.      modCount++;  
3.      ensureCapacityHelper(elementCount + 1);  
4.      elementData[elementCount++] = e;  
5.      return true;  
6.  }  
7.   
8.  private void ensureCapacityHelper(int minCapacity) {  
9.      // overflow-conscious code  
10.      if (minCapacity - elementData.length > 0)  
11.          grow(minCapacity);  
12.  }  
13.   
14.  private void grow(int minCapacity) {  
15.      // overflow-conscious code  
16.      int oldCapacity = elementData.length;  
17.      int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
18.                                       capacityIncrement : oldCapacity);  
19.   
20.      /** 
21.  
22.      这个扩容需要做个判断：如果容量增量初始化的不是0，即使用的public Vector(int initialCapacity,int capacityIncrement) 
23.  
24.      构造方法进行的初始化，那么扩容的容量是(oldCapacity+capacityIncrement)，就是原来的容量加上容量增量的值； 
25.  
26.      如果没有设置容量增量，那么扩容后的容量就是(oldCapacity+oldCapacity)，就是原来容量的二倍。 
27.  
28.      **/  
29.   
30.      if (newCapacity - minCapacity < 0)  
31.          newCapacity = minCapacity;  
32.      if (newCapacity - MAX_ARRAY_SIZE > 0)  
33.          newCapacity = hugeCapacity(minCapacity);  
34.      elementData = Arrays.copyOf(elementData, newCapacity);  
35.  }  
36.   
37. //jdk1.6版本是这样的：       
38. private void ensureCapacityHelper(int minCapacity) {  
39.        int oldCapacity = elementData.length;  
40.        if (minCapacity > oldCapacity) {  
41.             Object[] oldData = elementData;  
42.             int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)  
43.                       : (oldCapacity * 2);//方式与jdk1.7一样  
44.             if (newCapacity < minCapacity) {  
45.                  newCapacity = minCapacity;  
46.             }  
47.             elementData = Arrays.copyOf(elementData, newCapacity);  
48.        }  
49.   }