圖解集合1：ArrayList

五月的倉頡發表於2015-11-29
原文網址 : https://www.cnblogs.com/xrq730/p/4989451.html
圖解

前言

這個分類中，將會寫寫Java中的集合。集合是Java中非常重要而且基礎的內容，因為任何資料必不可少的就是該資料是如何儲存的，集合的作用就是以一定的方式組織、儲存資料。這裡寫的集合，一部分是比較常見的、一部分是不常用但是我個人平時見到過的，一些比較相似的集合（比如HashMap和Hashtable）就只講一個，突出它們之間的區別即可。

最後，要指出一點，對於集合，我認為關注的點主要有四點：

1、是否允許空

2、是否允許重複資料

3、是否有序，有序的意思是讀取資料的順序和存放資料的順序是否一致

4、是否執行緒安全

 

ArrayList

ArrayList是最常見以及每個Java開發者最熟悉的集合類了，顧名思義，ArrayList就是一個以陣列形式實現的集合，以一張表格來看一下ArrayList裡面有哪些基本的元素：

元    素 作    用
private transient Object[] elementData; ArrayList是基於陣列的一個實現，elementData就是底層的陣列
private int size; ArrayList裡面元素的個數，這裡要注意一下，size是按照呼叫add、remove方法的次數進行自增或者自減的，所以add了一個null進入ArrayList，size也會加1 

 

四個關注點在ArrayList上的答案

以後每篇文章在講解程式碼前，都會先對於一個集合關注的四個點以表格形式做一個解答：

關  注  點 結      論
ArrayList是否允許空 允許
ArrayList是否允許重複資料 允許
ArrayList是否有序 有序
ArrayList是否執行緒安全 非執行緒安全

 

新增元素

有這麼一段程式碼：

public static void main(String[] args)
{
    List<String> list = new ArrayList<String>();
    list.add("000");
    list.add("111");
}

看下底層會做什麼，進入add方法的原始碼來看一下：

1 public boolean add(E e) {
2 ensureCapacity(size + 1);  // Increments modCount!!
3 elementData[size++] = e;
4 return true;
5 }

先不去管第2行的ensureCapacity方法，這個方法是擴容用的，底層實際上在呼叫add方法的時候只是給elementData的某個位置新增了一個資料而已，用一張圖表示的話是這樣的：

多說一句，我這麼畫圖有一定的誤導性。elementData中儲存的應該是堆記憶體中元素的引用，而不是實際的元素，這麼畫給人一種感覺就是說elementData陣列裡面存放的就是實際的元素，這是不太嚴謹的。不過這麼畫主要是為了方便起見，只要知道這個問題就好了。

 

擴容

我們看一下，構造ArrayList的時候，預設的底層陣列大小是10：

public ArrayList() {
this(10);
}

那麼有一個問題來了，底層陣列的大小不夠了怎麼辦？答案就是擴容，這也就是為什麼一直說ArrayList的底層是基於動態陣列實現的原因，動態陣列的意思就是指底層的陣列大小並不是固定的，而是根據新增的元素大小進行一個判斷，不夠的話就動態擴容，擴容的程式碼就在ensureCapacity裡面：

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);
}
}

看到擴容的時候把元素組大小先乘以3，再除以2，最後加1。可能有些人要問為什麼？我們可以想：

1、如果一次性擴容擴得太大，必然造成記憶體空間的浪費

2、如果一次性擴容擴得不夠，那麼下一次擴容的操作必然比較快地會到來，這會降低程式執行效率，要知道擴容還是比較耗費效能的一個操作

所以擴容擴多少，是JDK開發人員在時間、空間上做的一個權衡，提供出來的一個比較合理的數值。最後呼叫到的是Arrays的copyOf方法，將元素組裡面的內容複製到新的陣列裡面去：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
       T[] copy = ((Object)newType == (Object)Object[].class)
           ? (T[]) new Object[newLength]
           : (T[]) Array.newInstance(newType.getComponentType(), newLength);
       System.arraycopy(original, 0, copy, 0,
                        Math.min(original.length, newLength));
       return copy;
}

用一張圖來表示就是這樣的：

 

刪除元素

接著我們看一下刪除的操作。ArrayList支援兩種刪除方式：

1、按照下標刪除

2、按照元素刪除，這會刪除ArrayList中與指定要刪除的元素匹配的第一個元素

對於ArrayList來說，這兩種刪除的方法差不多，都是呼叫的下面一段程式碼：

int numMoved = size - index - 1;
if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
             numMoved);
elementData[--size] = null; // Let gc do its work

其實做的事情就是兩件:

1、把指定元素後面位置的所有元素，利用System.arraycopy方法整體向前移動一個位置

2、最後一個位置的元素指定為null，這樣讓gc可以去回收它

比方說有這麼一段程式碼：

public static void main(String[] args)
{
    List<String> list = new ArrayList<String>();
    list.add("111");
    list.add("222");
    list.add("333");
    list.add("444");
    list.add("555");
    list.add("666");
    list.add("777");
    list.add("888");
    list.remove("333");
}

用圖表示是這樣的：

 

插入元素

看一下ArrayList的插入操作，插入操作呼叫的也是add方法，比如：

 1 public static void main(String[] args)
 2 {
 3     List<String> list = new ArrayList<String>();
 4     list.add("111");
 5     list.add("222");
 6     list.add("333");
 7     list.add("444");
 8     list.add("555");
 9     list.add("666");
10     list.add("777");
11     list.add("888");
12     list.add(2, "000");
13     System.out.println(list);
14 }

有一個地方不要搞錯了，第12行的add方法的意思是，往第幾個元素後面插入一個元素，像第12行就是往第二個元素後面插入一個000。看一下執行結果也證明了這一點：

[111, 222, 000, 333, 444, 555, 666, 777, 888]

還是看一下插入的時候做了什麼：

 1 public void add(int index, E element) {
 2 if (index > size || index < 0)
 3     throw new IndexOutOfBoundsException(
 4     "Index: "+index+", Size: "+size);
 5     ensureCapacity(size+1);  // Increments modCount!!
 6 System.arraycopy(elementData, index, elementData, index + 1,
 7          size - index);
 8 elementData[index] = element;
 9 size++;
10 }

看到插入的時候，按照指定位置，把從指定位置開始的所有元素利用System.arraycopy方法做一個整體的複製，向後移動一個位置（當然先要用ensureCapacity方法進行判斷，加了一個元素之後陣列會不會不夠大），然後指定位置的元素設定為需要插入的元素，完成了一次插入的操作。用圖表示這個過程是這樣的：

 

ArrayList的優缺點

從上面的幾個過程總結一下ArrayList的優缺點。ArrayList的優點如下：

1、ArrayList底層以陣列實現，是一種隨機訪問模式，再加上它實現了RandomAccess介面，因此查詢也就是get的時候非常快

2、ArrayList在順序新增一個元素的時候非常方便，只是往陣列裡面新增了一個元素而已

不過ArrayList的缺點也十分明顯：

1、刪除元素的時候，涉及到一次元素複製，如果要複製的元素很多，那麼就會比較耗費效能

2、插入元素的時候，涉及到一次元素複製，如果要複製的元素很多，那麼就會比較耗費效能

因此，ArrayList比較適合順序新增、隨機訪問的場景。

 

ArrayList和Vector的區別

ArrayList是執行緒非安全的，這很明顯，因為ArrayList中所有的方法都不是同步的，在併發下一定會出現執行緒安全問題。那麼我們想要使用ArrayList並且讓它執行緒安全怎麼辦？一個方法是用Collections.synchronizedList方法把你的ArrayList變成一個執行緒安全的List，比如：

List<String> synchronizedList = Collections.synchronizedList(list);
synchronizedList.add("aaa");
synchronizedList.add("bbb");
for (int i = 0; i < synchronizedList.size(); i++)
{
    System.out.println(synchronizedList.get(i));
}

另一個方法就是Vector，它是ArrayList的執行緒安全版本，其實現90%和ArrayList都完全一樣，區別在於：

1、Vector是執行緒安全的，ArrayList是執行緒非安全的

2、Vector可以指定增長因子，如果該增長因子指定了，那麼擴容的時候會每次新的陣列大小會在原陣列的大小基礎上加上增長因子；如果不指定增長因子，那麼就給原陣列大小*2，原始碼是這樣的：

int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                 capacityIncrement : oldCapacity);

 

為什麼ArrayList的elementData是用transient修飾的？

最後一個問題，我們看一下ArrayList中的陣列，是這麼定義的：

private transient Object[] elementData;

不知道大家有沒有想過，為什麼elementData是使用transient修飾的呢？關於這個問題，說說我的看法。我們看一下ArrayList的定義：

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

看到ArrayList實現了Serializable介面，這意味著ArrayList是可以被序列化的，用transient修飾elementData意味著我不希望elementData陣列被序列化。這是為什麼？因為序列化ArrayList的時候，ArrayList裡面的elementData未必是滿的，比方說elementData有10的大小，但是我只用了其中的3個，那麼是否有必要序列化整個elementData呢？顯然沒有這個必要，因此ArrayList中重寫了writeObject方法：

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
        // Write out array length
       s.writeInt(elementData.length);
    // Write out all elements in the proper order.
for (int i=0; i<size; i++)
           s.writeObject(elementData[i]);
    if (modCount != expectedModCount) {
           throw new ConcurrentModificationException();
    }
}

每次序列化的時候呼叫這個方法，先呼叫defaultWriteObject()方法序列化ArrayList中的非transient元素，elementData不去序列化它，然後遍歷elementData，只序列化那些有的元素，這樣：

1、加快了序列化的速度

2、減小了序列化之後的檔案大小

不失為一種聰明的做法，如果以後開發過程中有遇到這種情況，也是值得學習、借鑑的一種思路。

相關文章