集合——Vector和ArrayList的比較

今天研究了一下Vector和ArrayList的源碼，又加深了對這兩個類的理解。

List接口下一共實現了三個類：ArrayList，Vector，LinkedList。LinkedList就很少說了，它通常主要用在保持數據的插入順序的時候。ArrayList和Vector都是用數組實現的，主要有這麼三個區別：

一、Vector是多線程安全的，而ArrayList不是，這個能夠從源碼中看出，Vector類中的方法不少有synchronized進行修飾，這樣就致使了Vector在效率上沒法與ArrayList相比；

二、兩個都是採用的線性連續空間存儲元素，可是當空間不足的時候，兩個類的增長方式是不一樣的，不少網友說Vector增長原來空間的一倍，ArrayList增長原來空間的50%，其實也差很少是這個意思，不過還有一點點問題能夠從源碼中看出，一下子從源碼中分析。

三、Vector能夠設置增加因子，而ArrayList不能夠，最開始看這個的時候，我沒理解什麼是增量因子，不過經過對比一下兩個源碼理解了這個，先看看兩個類的構造方法：

ArrayList有三個構造方法：分別是

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

Vector有四個構造方法：

public Vector()//使用指定的初始容量和等於零的容量增量構造一個空向量。  
public Vector(int initialCapacity)//構造一個空向量，使其內部數據數組的大小，其標準容量增量爲零。  
public Vector(Collection<? extends E> c)//構造一個包含指定 collection 中的元素的向量  
public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量構造一個空的向量

Vector比Arraylist多一個構造方法，沒錯就是public Vector(int initialCapacity,int capacityIncrement)這個構造方法，capacityIncrement就是容量增加，即前面所說的增加因子，ArrayList中是沒有的。

再貼出兩個類的添加源碼分析下（jdk1.7版本）：

ArrayList類：

public boolean add(E e) {  
    ensureCapacityInternal(size + 1);  // Increments modCount!!  
    elementData[size++] = e;  
    return true;  
}  
  
private void ensureCapacityInternal(int minCapacity) {  
    modCount++;  
    // overflow-conscious code  
  
    //若是添加一個元素以後，新容器的大小大於容器的容量，那麼就沒法存值了，須要擴充空間  
    if (minCapacity - elementData.length > 0)  
  
        grow(minCapacity);  
}  
  
private void grow(int minCapacity) {  
    // overflow-conscious code  
    int oldCapacity = elementData.length;  
    int newCapacity = oldCapacity + (oldCapacity >> 1); //擴充的空間增長原來的50%（便是原來的1.5倍）  
    if (newCapacity - minCapacity < 0) //若是容器擴容以後仍是不夠，那麼幹脆直接將minCapacity設爲容器的大小  
        newCapacity = minCapacity;  
    if (newCapacity - MAX_ARRAY_SIZE > 0) //若是擴充的容器太大了的話，那麼就執行hugeCapacity  
        newCapacity = hugeCapacity(minCapacity);  
    // minCapacity is usually close to size, so this is a win:  
    elementData = Arrays.copyOf(elementData, newCapacity);  
}  
  
 //jdk1.6版本是這樣的：  
  
 public void ensureCapacity(int minCapacity) {  
      modCount++;  
      int oldCapacity = elementData.length;  
      if (minCapacity > oldCapacity) {  
           Object oldData[] = elementData;  
           int newCapacity = (oldCapacity * 3) / 2 + 1;  
           if (newCapacity < minCapacity)  
                newCapacity = minCapacity;  
           // minCapacity is usually close to size, so this is a win:  
           elementData = Arrays.copyOf(elementData, newCapacity);  
      }  
 }

1. Vector類：

 public synchronized boolean add(E e) {  
     modCount++;  
     ensureCapacityHelper(elementCount + 1);  
     elementData[elementCount++] = e;  
     return true;  
 }  
  
 private void ensureCapacityHelper(int minCapacity) {  
     // overflow-conscious code  
     if (minCapacity - elementData.length > 0)  
         grow(minCapacity);  
 }  
  
 private void grow(int minCapacity) {  
     // overflow-conscious code  
     int oldCapacity = elementData.length;  
     int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
                                      capacityIncrement : oldCapacity);  
  
     /** 
 
     這個擴容須要作個判斷：若是容量增量初始化的不是0，即便用的public Vector(int initialCapacity,int capacityIncrement) 
 
     構造方法進行的初始化，那麼擴容的容量是(oldCapacity+capacityIncrement)，就是原來的容量加上容量增量的值； 
 
     若是沒有設置容量增量，那麼擴容後的容量就是(oldCapacity+oldCapacity)，就是原來容量的二倍。 
 
     **/  
  
     if (newCapacity - minCapacity < 0)  
         newCapacity = minCapacity;  
     if (newCapacity - MAX_ARRAY_SIZE > 0)  
         newCapacity = hugeCapacity(minCapacity);  
     elementData = Arrays.copyOf(elementData, newCapacity);  
 }  
  
//jdk1.6版本是這樣的：       
private void ensureCapacityHelper(int minCapacity) {  
       int oldCapacity = elementData.length;  
       if (minCapacity > oldCapacity) {  
            Object[] oldData = elementData;  
            int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)  
                      : (oldCapacity * 2);//方式與jdk1.7同樣  
            if (newCapacity < minCapacity) {  
                 newCapacity = minCapacity;  
            }  
            elementData = Arrays.copyOf(elementData, newCapacity);  
       }