Java基礎系列--集合之ArrayList

原創做品，能夠轉載，可是請標註出處地址：http://www.cnblogs.com/V1haoge/p/8494618.html

1、概述

　　ArrayList是Java集合體系中最常使用，也是最簡單的集合類，是以數組實現的線性表。

　　數組在內存中是以一段連續的內存來進行存放的，一樣，ArrayList也是如此，初始化時能夠指定初始容量，也能夠以默認容量（10）建立底層數組，因爲ArrayList屬於可變長列表，採用可變數組實現，數組自己是不變的，一旦定義就沒法變長，可變數組使用建立新數組拷貝舊數據的方式間接實現可變長，習慣稱爲擴容。

　　ArrayList底層數組的擴容算法依據的是一個擴容算法來計算新的數組長度，擴容的條件是當前底層數組不足以容納新的元素。

2、繼承結構 

　　ArrayList的類結構以下所示：

3、底層實現

3.1 底層結構

　　如前所述，ArrayList底層採用的是數組結構。

1     private transient Object[] elementData;

　　elementData就是定義在ArrayList底層的數組，而數組就是一連串連續的內存，其邏輯結構以下：

　　上圖表示初始容量爲10的ArrayList的底層數組，默認的初始容量爲10，而列表長度用size來定義：

1     private int size;

　　這個表示的是列表中元素的數量，與數組的長度不一樣，size默認爲0，表示列表爲空。

3.2 添加元素

　　初始化的ArrayList的底層數組是沒有元素的，即數組的各位均爲null。使用add方法咱們能夠爲列表添加元素，ArrayList中的添加單個元素有兩種方式，一種是直接添加，另外一種是定位添加。還有添加一組元素的兩種方法，一種是定組直接添加，一種是定位定組添加

3.2.1 直接添加

　　所謂直接添加就是將新元素添加到列表末尾，其實現邏輯以下：

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

　　上面的邏輯很簡單，首先進行列表容量檢測（容後詳述），而後直接將新元素放置到底層數組中便可。

　　圖中顯示添加新元素到列表中，添加以後size的值會增長，這個size即指向數組最新空位的下標，有表明數組中元素的個數。

3.2.2 定位添加

　　所謂定位添加，就是咱們將新元素，添加到列表指定下標處。

1     public void add(int index, E element) {
2         rangeCheckForAdd(index);
3 
4         ensureCapacityInternal(size + 1);  // Increments modCount!!
5         System.arraycopy(elementData, index, elementData, index + 1,
6                          size - index);
7         elementData[index] = element;
8         size++;
9     }

　　首先進行index參數校驗，校驗經過後進行列表容量檢測（容後詳述），而後將指定下標處開始到結尾的因此元素總體後移覺得，下標處空出來後填充新添加的元素。這個添加操做涉及到一部分元素的總體移動，較爲耗時，具體視實際移動的元素數量而定。

　　實例：原始列表中由e1-e5共5個元素，如今執行add(2,e6)，表示在下標2處添加元素e6，執行步驟以下：

　　注意：add(int,E)方法底層數組元素的後移操做採用的是System.arraycopy()方法實現的，不只此處，後面還會屢次使用這個方法來實現數組元素的拷貝。

3.2.3 定組直接添加

　　定組直接添加方法爲：addAll(Collection<? extends E>)，直接將給定的集合中的元素依次添加到當前列表的後面。

1     public boolean addAll(Collection<? extends E> c) {
2         Object[] a = c.toArray();
3         int numNew = a.length;
4         ensureCapacityInternal(size + numNew);  // Increments modCount
5         System.arraycopy(a, 0, elementData, size, numNew);
6         size += numNew;
7         return numNew != 0;
8     }

　　首先進行集合轉化，將其轉化爲數組，獲取其長度（元素個數），進行列表容量檢測（容後詳述），將轉化好的數組元素複製到當前列表的底層數組後面，計算size。

　　明顯相似於直接添加，只是添加的數量不一樣而已，作個簡單的圖示：

　　只是這裏講給定的集合簡化爲數組形式，其實在源碼中咱們也能發現，在第2行對集合進行了數組轉化，便於操做。元素的添加仍是使用數組拷貝的形式實現。

3.2.4 定位定組添加

 　　定位定組添加相似於定位添加，一樣只是添加的元素個數不一樣。

 1     public boolean addAll(int index, Collection<? extends E> c) {
 2         rangeCheckForAdd(index);
 3 
 4         Object[] a = c.toArray();
 5         int numNew = a.length;
 6         ensureCapacityInternal(size + numNew);  // Increments modCount
 7 
 8         int numMoved = size - index;
 9         if (numMoved > 0)
10             System.arraycopy(elementData, index, elementData, index + numNew,
11                              numMoved);
12 
13         System.arraycopy(a, 0, elementData, index, numNew);
14         size += numNew;
15         return numNew != 0;
16     }

　　首先進行index參數校驗，而後將集合轉化爲數組，獲取其中元素個數numNew，再進行列表容量檢測，獲取須要後移的元素的個數，使用數組複製的方式將這些元素後移，再將轉化的數組元素複製遷移到空出的空位處。計算size。

　　參照下方實例，原始列表有兩個元素：e一、e2，如今給定集合包含3個元素，e三、e四、e5，如今執行add(1,Collection<? extends E>)

　　也就是將給定集合的元素嵌入到當前列表中。

 3.3 獲取元素

　　獲取指定下標處的元素，複雜度O(1)，只要獲取數組執行下標處的元素就能夠。

1     public E get(int index) {
2         rangeCheck(index);
3 
4         return elementData(index);
5     }

　　首先進行index參數校驗，而後獲取返回數組執行下標的元素。

3.4 修改元素

　　修改元素須要提供修改下標和新值，直接用新值替換舊值便可。

1     public E set(int index, E element) {
2         rangeCheck(index);
3 
4         E oldValue = elementData(index);
5         elementData[index] = element;
6         return oldValue;
7     }

　　首先進行index參數校驗，而後保存指定下標的舊值，替換爲新值，將舊值返回。

3.5 刪除元素

　　刪除元素的操做挺多的，針對不一樣的狀況：

3.5.1 定位刪除

　　定位刪除，即刪除指定下標的元素，須要提供刪除的元素的下標。

 1     public E remove(int index) {
 2         rangeCheck(index);
 3 
 4         modCount++;
 5         E oldValue = elementData(index);
 6 
 7         int numMoved = size - index - 1;
 8         if (numMoved > 0)
 9             System.arraycopy(elementData, index+1, elementData, index,
10                              numMoved);
11         elementData[--size] = null; // Let gc do its work　　
12 
13         return oldValue;
14     }

　　首先進行index參數校驗，modCount自增1，保存指定下標處的舊值，而後將指定下標的下一個元素到結尾的元素總體前移一位，後面元素覆蓋前面元素，指定下標處的舊值被刪除，而後將原來的末尾元素置空，size自減1，最後將舊值返回。

　　一樣數組元素的移動採用數組複製的方式實現。

　　實例：原始列表擁有5個元素，e1-e5，現移除下標2處的元素：remove(2)

 

 3.5.2 定元素刪除

　　指定要刪除的元素的值，在列表中查詢該值，刪除查詢到的第一個。即該方法只會刪除符合條件的首個元素（即便列表中存在多個符合條件的元素）。

 1     public boolean remove(Object o) {
 2         if (o == null) {
 3             for (int index = 0; index < size; index++)
 4                 if (elementData[index] == null) {
 5                     fastRemove(index);
 6                     return true;
 7                 }
 8         } else {
 9             for (int index = 0; index < size; index++)
10                 if (o.equals(elementData[index])) {
11                     fastRemove(index);
12                     return true;
13                 }
14         }
15         return false;
16     }
17 
18     private void fastRemove(int index) {
19         modCount++;
20         int numMoved = size - index - 1;
21         if (numMoved > 0)
22             System.arraycopy(elementData, index+1, elementData, index,
23                              numMoved);
24         elementData[--size] = null; // Let gc do its work
25     }

　　指定元素進行刪除的狀況，較爲複雜，須要針對元素的狀況進行分析，若是指定元素爲null，則刪除第一個null元素，若指定元素非null，則查詢首個符合條件的元素進行刪除。

　　欲刪除元素，必須先找到要刪除元素的下標，這個過程由循環實現（第3行和第9行），找到下標以後，調用內部方法fastRemove(int)，進行指定下標元素的刪除，即定位刪除，而後返回true，表示刪除成功。

　　還有一種狀況那就是指定的元素在列表中查詢不到，這是直接返回false便可。

　　這種刪除底層使用的仍然是定位刪除。不在畫圖舉例了。

 3.5.3 定組刪除

　　所謂定組刪除，就是刪除當前列表中因此與給定集合中元素相同的元素，該操做須要制定一個欲要刪除的元素的集合（Collection）。

 1     public boolean removeAll(Collection<?> c) {
 2         return batchRemove(c, false);
 3     }
 4 
 5     private boolean batchRemove(Collection<?> c, boolean complement) {
 6         final Object[] elementData = this.elementData;
 7         int r = 0, w = 0;
 8         boolean modified = false;
 9         try {
10             for (; r < size; r++)
11                 if (c.contains(elementData[r]) == complement)
12                     elementData[w++] = elementData[r];
13         } finally {
14             // Preserve behavioral compatibility with AbstractCollection,
15             // even if c.contains() throws.
16             if (r != size) {
17                 System.arraycopy(elementData, r,
18                                  elementData, w,
19                                  size - r);
20                 w += size - r;
21             }
22             if (w != size) {
23                 for (int i = w; i < size; i++)
24                     elementData[i] = null;
25                 modCount += size - w;
26                 size = w;
27                 modified = true;
28             }
29         }
30         return modified;
31     }

　　定組刪除的complement傳值爲false，用於第11行比較，表示若是給定集合中不包含當前列表的當前下標的元素的狀況下，執行內部語句塊，將這個元素保留下來（亦即若包含該元素則不保留該元素，最後查遺補漏時，會將其消失【finally塊邏輯】）

實例：當前列表是包含5個元素e1-e5，給定集合元素包括e2,e3,e5三個元素，則定位刪除的圖示爲：

　　從第二步開始循環，每次循環結束，r就會自增1，而w表示的是下一個保留元素的下標或者保留元素的個數。循環在第七步r自增到5，不知足循環條件時結束，最後r=5，w=2，亦即共刪除3個元素，modCount須要自增（r-w=5-2=3）次。

　　最後finally中執行第二個if塊，將多餘的元素位置置null，再計算modCount和size。

3.5.4 定組保留刪除

　　定組保留刪除邏輯與定組刪除正好相反，須要將給定集合中包含的當前列表的元素保留下來，將不包含的刪除。

1     public boolean retainAll(Collection<?> c) {
2         return batchRemove(c, true);
3     }

 

　　實例，同上，圖示以下：

　　執行過程同上。

3.5.5 範圍刪除

　　ArrayList中還有一個範圍刪除方法：removeRange(int,int)，根據給定的兩個下標，刪除下標範圍以內的全部元素。該方法是protected修飾的，那麼很明顯，這個方法並非面向ArrayList使用者的，而是面向JDK實現者的，這裏只作簡單介紹。

 1     protected void removeRange(int fromIndex, int toIndex) {
 2         modCount++;
 3         int numMoved = size - toIndex;
 4         System.arraycopy(elementData, toIndex, elementData, fromIndex,
 5                          numMoved);
 6 
 7         // Let gc do its work
 8         int newSize = size - (toIndex-fromIndex);
 9         while (size != newSize)
10             elementData[--size] = null;
11     }

　　很簡單，將toIndex到結尾的元素複製到fromIndex，空出的位置所有置空便可。

3.6 查找元素

　　查找元素包括3個方法：

　　　　contains(Object)　　檢查當前列表是否包含某個元素

　　　　indexOf(Object)　　檢查給定元素在當前列表中首次出現的下標

　　　　lastIndexOf(Object)　　檢查給定元素在當前列表中最後出現的下標

3.6.1 包含方法

1     public boolean contains(Object o) {
2         return indexOf(o) >= 0;
3     }

　　好傢伙，本身啥也不幹，就靠後面了...

3.6.2 前序查找

　　前序查找就是從頭開始查找元素，返回首次出現的下標。

 1     public int indexOf(Object o) {
 2         if (o == null) {
 3             for (int i = 0; i < size; i++)
 4                 if (elementData[i]==null)
 5                     return i;
 6         } else {
 7             for (int i = 0; i < size; i++)
 8                 if (o.equals(elementData[i]))
 9                     return i;
10         }
11         return -1;
12     }

　　源碼顯示，須要分兩種狀況考慮，若是給定元素爲null，則查找首個null元素的下標並返回，若是給定元素非null，則查找首次出現的下標並返回，若是列表中不包含該元素，則返回-1。

3.6.3 後序查找

 　　後序查找就是前序查找的反向查找方式：

 1     public int lastIndexOf(Object o) {
 2         if (o == null) {
 3             for (int i = size-1; i >= 0; i--)
 4                 if (elementData[i]==null)
 5                     return i;
 6         } else {
 7             for (int i = size-1; i >= 0; i--)
 8                 if (o.equals(elementData[i]))
 9                     return i;
10         }
11         return -1;
12     }

　　參考先後查找的源碼不難發現，模式一致，只是查找的方向不一樣而已。

3.7 列表擴容

　　列表的擴容是底層自動進行的，對列表的使用者是徹底透明的，所以其方法都是私有的。擴容的條件與算法並不複雜：

 1     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 2 
 3     private void ensureCapacityInternal(int minCapacity) {
 4         modCount++;
 5         // overflow-conscious code
 6         if (minCapacity - elementData.length > 0)
 7             grow(minCapacity);
 8     }
 9 
10     private void grow(int minCapacity) {
11         // overflow-conscious code
12         int oldCapacity = elementData.length;
13         int newCapacity = oldCapacity + (oldCapacity >> 1);
14         if (newCapacity - minCapacity < 0)
15             newCapacity = minCapacity;
16         if (newCapacity - MAX_ARRAY_SIZE > 0)
17             newCapacity = hugeCapacity(minCapacity);
18         // minCapacity is usually close to size, so this is a win:
19         elementData = Arrays.copyOf(elementData, newCapacity);
20     }
21 
22     private static int hugeCapacity(int minCapacity) {
23         if (minCapacity < 0) // overflow
24             throw new OutOfMemoryError();
25         return (minCapacity > MAX_ARRAY_SIZE) ?
26             Integer.MAX_VALUE :
27             MAX_ARRAY_SIZE;
28     }

　　擴容條件：拿給定的容量（長度值）minCapacity與當前列表的底層數組的容量elementData.length進行比較，若是前者大，則說明容量不足，須要擴容，調用grow(minCapacity)進行擴容。

　　擴容算法：擴容時存在三種狀況，第一種就是普通的自動擴容，按照oldCapacity + (oldCapacity >> 1)算法進行擴容，上式計算得出的即爲新的數組容量，通常針對的是單個元素添加的狀況，即直接添加和定位添加的狀況，這種狀況下，每次只添加一個元素，不會出現第14行成功的可能，可是若是是定組直接添加和定位定組添加的時候，因爲添加的集合元素數量未知，一旦給定的minCapacity比計算得出的新容量要大，說明計算得出的容量不足以容納全部的元素，這是直接使用minCapacity做爲新容量進行擴容。即優先使用算法計算的容量進行擴容，一旦計算容量還不足以容納新元素，則使用給定的容量進行擴容。

　　還有一種特殊狀況，當本次擴容時，計算獲得的容量，或者給定的容量大於MAX_ARRAY_SIZE（=Integer.MAX_VALUE - 8）的狀況下，須要調用hugeCapacity(minCapacity)方法進行人爲限制容量超限，將容量限制在整形的最大值以內。

　　最後進行數組擴容，建立新數組，拷貝數據。

3.8 迭代器

　　列表的迭代必不可少，並且這裏還會用到一個出現好久的變量modCount，此前咱們對它一無所知。

　　modCount記錄的是列表結構發生變化的次數，所謂結構變化包括：新增元素，刪除元素，清空元素，擴容等。

　　ArrayList的迭代器有兩種，ListIterator和Iterator。兩者雖然都是迭代器，可是仍是有些不一樣的。