JDK1.8源碼(六)——java.util.ArrayList類

一、概述

1、介紹

　　ArrayList元素是有序的，可重復。線程不安全的。底層維護一個 Object 數組。
　　JDK1.7：ArrayList像餓漢式，默認初始長度直接創建一個容量為 10 的數組。
　　JDK1.8：ArrayList像懶漢式，默認一開始創建一個長度為 0 的數組，當添加第一個元素時再創建一個始容量為10的數組。
　　默認情況擴容都為原來數組的 1.5 倍。

　　繼承關系：

　　擴容原理：

2、遍歷方式

　　①隨機訪問
　　由於實現了 RandomAccess 接口，它支持通過索引值去隨機訪問元素。

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

　　②增強forEach，底層還是使用的迭代器

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");
for (String s : list) {
    System.out.println(s);
}

　　這種語法可以看成是 JDK 的一種語法糖，通過反編譯 class 文件，可以看到生成的 java 文件，還是通過調用 Iterator 迭代器來遍歷的。

for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    iterator.next();
}

　　③迭代器 iterator

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

　　④迭代器 ListIterator

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final ListIterator<String> iterator = list.listIterator();
// 向后遍歷
while (iterator.hasNext()) {
    System.out.println(iterator.next()); // 1 3 2
}

// 向前遍歷.此時由於上面進行了向后遍歷,游標指向了最后一個元素,所以此處向前遍歷能有值
while (iterator.hasPrevious()) {
    System.out.println(iterator.previous()); // 2 3 1
}

二、類源碼

1、類聲明

　　源碼示例：

 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see     Collection
 * @see     List
 * @see     LinkedList
 * @see     Vector
 * @since   1.2
 */

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

　　繼承了AbstractList：AbstractList提供List接口的骨干實現，以最大限度地減少"隨機訪問"數據存儲（如ArrayList）實現Llist所需的工作。
　　實現了 List 接口：定義了實現該接口的類都必須要實現的一組方法，實現了所有可選列表操作。
　　實現了 RandmoAccess 接口：表明ArrayList支持快速（通常是固定時間）隨機訪問。此接口的主要目的是允許一般的算法更改其行為，從而在將其應用到隨機或連續訪問列表時能提供良好的性能。比如在工具類 Collections 中，應用二分查找方法時判斷是否實現了 RandomAccess 接口：

// Collections類
public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

　　實現了 Cloneable 接口：一個標記接口，接口內無任何方法體和常量的聲明。需要復寫Object.clone()函數，表示它可以被克隆。
　　實現了 Serializable 接口：一個標記接口，標識該類可序列化。

2、類屬性

　　源碼示例：讀一下源碼中的英文注釋。

private static final long serialVersionUID = 8683452581122892189L;

// 默認的初始化容量(大小)
/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

// 空的數組實例
/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

// 也是一個空的數組實例.個人覺得和上一個屬性沒啥區別
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 任何一個空的 elementData 就是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 當它第一次 add 元素的時候會被擴展到DEFAULT_CAPACITY,也就是 10
/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

// 容器的實際元素個數
private int size;

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

3、類構造器

　　源碼示例：三個重載（重要）
　　ArrayList list = new ArrayList(); // 集合長度初始化是0，而不是 10，JDK7才是10。

public ArrayList() {
    // 很清楚的看到,初始化的是一個空數組
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

　　ArrayList list = new ArrayList(7); // 指定大小時，初始多大就是多大。

// 不寫注釋也能看懂的代碼
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 大於 0 時, new 的數組大小就是多少
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 等於 0 時, 初始化的是一個空數組
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 否則,參數異常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

　　傳入一個集合。

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            // 數組拷貝
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 否則,就初始化一個空數組
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

4、add()方法

　　源碼示例：擴容原理

public boolean add(E e) {
    // 判斷是否需要擴容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 如果是第一次初始化的空數組
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // minCapacity = max(10,1) 體現出第一次 add 時,才初始化長度 10 的數組
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改次數+1.用於集合的快速失敗機制
    modCount++;

    // 需要擴容
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

　　源碼示例：真正擴容的方法

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    
    // 體現出擴容為原來的 1.5 倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 當新數組長度仍然比minCapacity小,則為保證最小長度,新數組等於minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
        
    // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 = 2147483639
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
        
    // 將原數組拷貝到一個大小為 newCapacity 的新數組（注意是拷貝引用）
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// 用於判斷容量是否超過最大值
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

　　說明：
　　modCount給ArrayList的迭代器使用的，在並發修改時，提供快速失敗行為，保證modCount在迭代期間不變，否則拋出ConcurrentModificationException異常。
　　ArrayList 的擴容，核心方法就是調用 Arrays.copyOf 方法，創建一個更大的數組，然后將原數組元素拷貝過去。
　　總結：
　　①當通過 ArrayList() 構造一個空集合，初始長度是為0的，第1次添加元素，會創建一個長度為10的數組，並將該元素賦值到數組的第一個位置。
　　②第2次添加元素，集合不為空，由於集合大小size + 1 < 數組的長度 10，所以直接添加元素到數組的第二個位置，不用擴容。
　　③第 11 次添加元素，此時 size+1 = 11 > 數組長度10。這時候創建一個長度為10+10*0.5 = 15 的數組（擴容1.5倍），然后將原數組元素引用拷貝到新數組。並將第 11 次添加的元素賦值到新數組下標為10的位置。
　　④第 Integer.MAX_VALUE - 8 = 2147483639，然后 2147483639%1.5=1431655759（這個數是要進行擴容）次添加元素，為了防止溢出，此時會直接創建一個 1431655759 + 1 大小的數組，這樣一直，每次添加一個元素，都只擴大一個范圍。
　　⑤第 Integer.MAX_VALUE - 7 次添加元素時，創建一個大小為 Integer.MAX_VALUE 的數組，在進行元素添加。
　　⑥第 Integer.MAX_VALUE + 1 次添加元素時，拋出 OutOfMemoryError 異常。

5、remove()方法

　　源碼示例：

// 根據索引刪除
public E remove(int index) {
    // 檢查索引 index 是否越界
    rangeCheck(index);

    modCount++;
    // 獲取索引處的元素
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    // 表示 0 <= index < (size-1),即索引不是最后一個元素
    if (numMoved > 0)
    // 將數組elementData的下標index+1之后長度為numMoved的元素拷貝到從index開始的位置
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 將數組最后一個元素置為 null, 便於垃圾回收                     
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

// 刪除指定元素
public boolean remove(Object o) {
    // 如果 o 為null
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 如果o不是null,則循環查找.刪除第一次出現的該元素
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
    // 通過System.arraycopy進行數組自身拷貝。
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

6、set()方法

　　源碼示例：將指定索引index處的元素修改。

public E set(int index, E element) {
    rangeCheck(index);

    // 獲取索引處的元素
    E oldValue = elementData(index);
    // 將index處元素修改為element
    elementData[index] = element;
    return oldValue;
}

// 很簡單.就是檢查索引合法性
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

7、get()方法

　　源碼示例：

public E get(int index) {
    rangeCheck(index);
    // 通過索引下標返回數組中的元素
    return elementData(index);
}

　　源碼示例：很簡單，略
　　indexOf(Object o)：返回集合中第一次出現該元素的下標，沒有則返回 -1。
　　lastIndexOf(Object o)：返回集合中最后一次出現該元素的下標。沒有則返回 -1。

8、SubList()

　　返回從 [fromIndex, toIndex) 的一個子串。但是注意，這里只是原集合的一個視圖。

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("3");
        list.add("2");

        List<String> subList = list.subList(0, 1);
        System.out.println(subList); // [1]

        subList.add("k");
        System.out.println(subList); // [1, k]

        // 對子串的添加影響了原集合
        System.out.println(list); // [1, k, 3, 2]
    }
}

　　想要獨立出來一個集合，解決辦法如下：

List<String> sub = new ArrayList<>(list.subList(0, 1));

9、Size()

public int size() {
    // 返回集合的大小
    return size;
}

10、isEmpty()

public boolean isEmpty() {
    // 集合是否為空
    return size == 0;
}

11、trimToSize()

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        // 如果集合大小為 0 ,則數組為空
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          
          // 否則,按集合實際大小拷貝一份數組
          : Arrays.copyOf(elementData, size);
    }
}

　　該方法用於回收多余的內存。可以在確定集合不在添加多余的元素之后，調用 trimToSize() 方法會將數組大小調整為集合元素的大小。
　　注意：該方法會花時間來復制數組元素，所以應該在確定不會添加元素之后在調用。

三、迭代器

1、iterator

　　源碼示例：

// 返回一個 Itr 對象.這個類是 ArrayList 的內部類。
public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    // 游標.下一個要返回的元素的索引
    int cursor;       // index of next element to return
    // 返回最后一個元素的索引; 如果沒有返回-1.
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    // 通過 cursor != size 判斷是否還有下一個元素
    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        // 迭代器進行元素迭代時同時進行增加和刪除操作，會拋出異常
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 游標向后移動一位    
        cursor = i + 1;
        // 返回索引為 i 處的元素,並將lastRet賦值為i
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            // 調用ArrayList的remove方法刪除元素
            ArrayList.this.remove(lastRet);
            // 游標指向刪除元素的位置，本來是lastRet+1的，這里刪除一個元素，然后游標就不變了
            cursor = lastRet;
            // 恢復默認值-1
            lastRet = -1;
            //expectedModCount值和modCount同步，因為進行add和remove操作，modCount會加1
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }


    // 在新增元素add() 和 刪除元素 remove() 時, modCount++。修改set() 是沒有的
    // 也就是說不能在迭代器進行元素迭代時進行增加和刪除操作，否則拋出異常
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

　　注意：在進行 next() 方法調用的時候，會進行 checkForComodification() 調用，該方法表示迭代器進行元素迭代時，如果同時進行增加和刪除操作，會拋出 ConcurrentModificationException 異常。比如：

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("3");
list.add("2");

final Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    final String next = iterator.next();

    // Exception in thread "main" java.util.ConcurrentModificationException
    // list.remove(next);
    list.set(0, "k");
    
    // 正確方式是調用迭代器的 remove 方法
    iterator.remove();
}

　　注意：迭代器只能向后遍歷，不能向前遍歷，能夠刪除元素，但是不能新增元素。

2、listIterator

　　這是 list 集合特有的迭代器。可以一邊遍歷，一邊新增或刪除。

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("3");
        list.add("2");

        final ListIterator<String> iterator = list.listIterator();
        // 向后遍歷
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " "); // 1 3 2

            iterator.add("K");
        }

        // [1, K, 3, K, 2, K]
        System.out.println("\n" + list);

        // 向前遍歷
        while (iterator.hasPrevious()) {
            System.out.print(iterator.previous() + " "); // K 2 K 3 K 1 
        }
    }
}

　　相比於 Iterator 迭代器， listIterator 多出了能向前迭代，以及新增元素的功能。
　　源碼示例：

public interface ListIterator<E> extends Iterator<E> {
    // 正向迭代.是否有下一個
    boolean hasNext();
    // 取下一個
    E next();
    // 反向迭代.是否有上一個
    boolean hasPrevious();
    // 取上一個
    E previous();
    int nextIndex();
    int previousIndex();
    // 刪除元素
    void remove();
    void set(E e);
    // 添加元素
    void add(E e);
}

　　在ArrayList類中，對上述接口的實現。

public ListIterator<E> listIterator() {
    return new ListItr(0);
}

// 一個內部類
private class ListItr extends Itr implements ListIterator<E> {
    // 進行游標初始化.默認是 0 
    ListItr(int index) {
        super();
        cursor = index;
    }
    // 是否有上一個元素
    public boolean hasPrevious() {
        return cursor != 0;
    }
    // 返回下一個元素的索引
    public int nextIndex() {
        return cursor;
    }
    // 返回上一個元素的索引
    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        // 迭代器進行元素迭代時同時進行增加和刪除操作，會拋出異常
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 游標指向上一個元素
        cursor = i;
        // 返回上一個元素的值
        return (E) elementData[lastRet = i];
    }

    public void set(E e) {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

　　參考文檔：https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#