Vector和ArrayList的比较

今天研究了一下Vector和ArrayList的源码，又加深了对这两个类的理解。

List接口下一共实现了三个类：ArrayList，Vector，LinkedList。LinkedList就不多说了，它一般主要用在保持数据的插入顺序的时候。ArrayList和Vector都是用数组实现的，主要有这么三个区别：

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

2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的，很多网友说Vector增加原来空间的一倍，ArrayList增加原来空间的50%，其实也差不多是这个意思，不过还有一点点问题可以从源码中看出，一会儿从源码中分析。

3、Vector可以设置增长因子，而ArrayList不可以，最开始看这个的时候，我没理解什么是增量因子，不过通过对比一下两个源码理解了这个，先看看两个类的构造方法：

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

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

 

Vector有四个构造方法：

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

Vector比Arraylist多一个构造方法，没错就是public Vector(int initialCapacity,int capacityIncrement)这个构造方法，capacityIncrement就是容量增长，即前面所说的增长因子，ArrayList中是没有的。

再贴出两个类的添加源码分析下（jdk1.7版本）：

ArrayList类：

 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类：

 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   }  

 

 

转载于:https://www.cnblogs.com/ncyhl/p/7453193.html