JDK版本：13

1 類圖

@[TOC]

1.1 實(shí)現(xiàn)接口

• java.util.List：提供增刪改查等基本操作
• java.io.Serializable：標(biāo)記接口，表示支持序列化
• java.lang.Cloneable：標(biāo)記接口褪那，表示支持克隆
• java.util.RandomAccess：這個(gè)接口可能很少注意到隔嫡，其實(shí)也是一個(gè)標(biāo)記接口，表示能夠隨機(jī)訪問元素书在，簡(jiǎn)單來說就是底層是數(shù)組實(shí)現(xiàn)的集合灰伟。參考：RandomAccess 這個(gè)空架子有何用？

1.2 繼承

• java.util.AbstractList：抽象類儒旬，從注釋中可以看到栏账，它提供了List接口的基本實(shí)現(xiàn)帖族，以最大程度地減少迭代遍歷相關(guān)操作的實(shí)現(xiàn)。不過ArrayList基本都重寫了AbstractList提供的實(shí)現(xiàn)挡爵。

2 屬性

• int elementData：儲(chǔ)存元素的數(shù)組竖般，ArrayList的真實(shí)大小
• int size：elementData中實(shí)際存放元素的數(shù)量，我們經(jīng)常調(diào)用的size()方法返回的也就是它

3 構(gòu)造方法

3.1 ArrayList(int initialCapacity)

    /**
     * 空數(shù)組茶鹃，當(dāng)初始化容量為0時(shí)涣雕，將elementData指向它
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    
    public ArrayList(int initialCapacity) {
        // 指定容量大于0 創(chuàng)建對(duì)應(yīng)的Object數(shù)組
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        // 等于0 使用 EMPTY_ELEMENTDATA 
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        // 小于0 拋出異常
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

盡量預(yù)估數(shù)組大小，使用該方法創(chuàng)建ArrayList闭翩，合理使用內(nèi)存胞谭，避免數(shù)組擴(kuò)容耗費(fèi)性能。

3.2 ArrayList()

    /**
     * Default initial capacity.
     * 默認(rèn)初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;
    
    /**
     * 使用默認(rèn)容量時(shí)的空數(shù)組男杈。當(dāng)使用無參構(gòu)造時(shí)丈屹，為了節(jié)省內(nèi)存（考慮到創(chuàng)建了ArrayList對(duì)象但沒使用的情況）
     * 做了優(yōu)化，在首次添加元素時(shí)伶棒，才將elementData初始化成長(zhǎng)度為10的數(shù)組旺垒。
     * 與EMPTY_ELEMENTDATA區(qū)分開，以便在初始化時(shí)知道是直接初始化成10肤无。
     * 而EMPTY_ELEMENTDATA從0開始按照1.5倍擴(kuò)容先蒋。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    
    /**
     * 使用默認(rèn)容量10創(chuàng)建ArrayList
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

3.3 ArrayList(Collection<? extends E> c)

    /**
     * 傳入一個(gè)集合來創(chuàng)建ArrayList
     */
    public ArrayList(Collection<? extends E> c) {
        // 將集合轉(zhuǎn)為Object數(shù)組
        elementData = c.toArray();
        // 如果數(shù)組長(zhǎng)度不等于0
        if ((size = elementData.length) != 0) {
            // defend against c.toArray (incorrectly) not returning Object[]
            // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
            
            // 如果elementData不是Object數(shù)組類型，就創(chuàng)建個(gè)新的Object類型數(shù)組宛渐，
            // 并將elementData中的元素賦值進(jìn)去竞漾，最終再把新數(shù)組賦值給elementData
            
            // 是為了修復(fù)JDK-626065的BUG，c.toArray不返回Ojbect[]類型數(shù)組
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        // 如果數(shù)組大小等于0窥翩，使用EMPTY_ELEMENTDATA
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
        
        // 业岁？？為什么一會(huì)用this.elementData寇蚊，一會(huì)又不加this.了
    }
    

4 主要方法

4.1 添加一個(gè)元素

boolean add(E e) 添加到尾部

    /**
     * 將一個(gè)元素添加到末尾
     */
    public boolean add(E e) {
        // 定義于父類AbstractList中笔时，用于記錄數(shù)組被修改的次數(shù)，+1
        modCount++;
        add(e, elementData, size);
        return true;
    }
    
    private void add(E e, Object[] elementData, int s) {
        // 如果容量不足仗岸，進(jìn)行擴(kuò)容
        if (s == elementData.length)
            elementData = grow();
        // 元素放到數(shù)組末尾
        elementData[s] = e;
        // size +1
        size = s + 1;
    }
    

void add(int index, E element) 添加到指定位置

    /**
     * 在指定位置插入一個(gè)元素
     */
    public void add(int index, E element) {
        // 檢查index是否在數(shù)組范圍內(nèi)
        rangeCheckForAdd(index);
        // 修改次數(shù) +1
        modCount++;
        final int s;
        Object[] elementData;
        // 如果容量不夠允耿，進(jìn)行擴(kuò)容
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        // 將index位置及之后的元素向后挪一位
        // 數(shù)組復(fù)制
        System.arraycopy(elementData, // 原數(shù)組
                         index, // 從原數(shù)組的開始位置
                         elementData, // 目標(biāo)數(shù)組
                         index + 1, // 在目標(biāo)數(shù)組的開始位置
                         s - index); // 復(fù)制元素的個(gè)數(shù)
        // 將插入元素放在index的位置
        elementData[index] = element;
        // size + 1
        size = s + 1;
    }

4.2 擴(kuò)容

Object[] grow()

    private Object[] grow() {
        // 擴(kuò)容后容量至少比以前大1
        return grow(size + 1);
    }
    
    /**
     * @param minCapacity 所需最小擴(kuò)容后容量
     */
    private Object[] grow(int minCapacity) {
        // 記錄老的容量
        int oldCapacity = elementData.length;
        // 如果容量 > 0 或 數(shù)組不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，計(jì)算新的容量大小并擴(kuò)容
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth 最小擴(kuò)大量*/
                    oldCapacity >> 1           /* preferred growth 首選擴(kuò)大量*/);
            // 把元素拷貝到新數(shù)組中
            return elementData = Arrays.copyOf(elementData, newCapacity);
            /*
                ArraysSupport.newLength 計(jì)算新數(shù)組大小扒怖，取 minimum growth 和
                preferred growth 的更大值加上舊的容量较锡。
                還涉及到一些數(shù)組最大長(zhǎng)度的校驗(yàn)和處理，這里不細(xì)說盗痒。

                >> 是移位運(yùn)算符蚂蕴，右移一位相當(dāng)于除以二，也就是說這里是擴(kuò)大到1.5倍
                如果是從0擴(kuò)容，0 >> 1 還是0掂墓，此時(shí)使用minCapacity，也就是1
            */
        // 如果是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA看成，創(chuàng)建新數(shù)組
        } else {
            // 容量取 默認(rèn)容量 和 minCapacity 中的更大值
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

4.3 添加多個(gè)元素

boolean addAll(Collection<? extends E> c) 向末尾添加

    /**
     * 向末尾添加多個(gè)元素
     * 調(diào)用此方法相比一個(gè)一個(gè)添加元素君编，可以避免數(shù)組多次擴(kuò)容
     */
    public boolean addAll(Collection<? extends E> c) {
        // 轉(zhuǎn)換成數(shù)組
        Object[] a = c.toArray();
        // 修改次數(shù)+1
        modCount++;
        // 新加入元素個(gè)數(shù)
        int numNew = a.length;
        // 如果個(gè)數(shù)為0，返回false川慌，ArrayList數(shù)組無變化吃嘿，但修改次數(shù)是增加了的
        if (numNew == 0)
            return false;
        Object[] elementData;
        final int s;
        // 如果新加入元素不夠放了，則進(jìn)行擴(kuò)容梦重，要求擴(kuò)容后至少能放得下新加入的數(shù)據(jù)
        if (numNew > (elementData = this.elementData).length - (s = size))
            elementData = grow(s + numNew);
        // 將新數(shù)組復(fù)制進(jìn)elementData的末尾
        System.arraycopy(a, 0, elementData, s, numNew);
        // 計(jì)算size大小
        size = s + numNew;
        return true;
    }

boolean addAll(int index, Collection<? extends E> c) 向指定位置添加

    public boolean addAll(int index, Collection<? extends E> c) {
        // 檢查是否越界
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        modCount++;
        int numNew = a.length;
        if (numNew == 0)
            return false;
        Object[] elementData;
        final int s;
        // 擴(kuò)容兑燥，至少裝得下新數(shù)組
        if (numNew > (elementData = this.elementData).length - (s = size))
            elementData = grow(s + numNew);

        int numMoved = s - index;
        // 如果index位置已有元素，則將它開始及之后的元素向后移出位置來
        if (numMoved > 0)
            System.arraycopy(elementData, index,
                             elementData, index + numNew,
                             numMoved);
        // 將新數(shù)組加入elementData指定的位置
        System.arraycopy(a, 0, elementData, index, numNew);
        size = s + numNew;
        return true;
    }

4.4 移除單個(gè)元素

E remove(int index) 移除指定位置的元素琴拧，并返回該元素

    public E remove(int index) {
        // 校驗(yàn) index不能 > size
        Objects.checkIndex(index, size);
        final Object[] es = elementData;

        // 記錄被刪除的值
        @SuppressWarnings("unchecked") E oldValue = (E) es[index];
        fastRemove(es, index);
        // 返回被刪除的值
        return oldValue;
    }

    /**
     * 負(fù)責(zé)刪除的核心邏輯降瞳，不關(guān)心返回被刪除元素或越界校驗(yàn)等操作
     */
    private void fastRemove(Object[] es, int i) {
        // 修改次數(shù)+1
        modCount++;
        final int newSize;
        // size是比下標(biāo)大 1 的，size-1 和 i 比較蚓胸，其實(shí)是在判斷i是不是數(shù)組最后一位
        // 如果不是最后一位挣饥，要把i后邊的所有元素向前挪一位。
        if ((newSize = size - 1) > i) // 注意這里藏著 size - 1 的操作
            System.arraycopy(es, i + 1, es, i, newSize - i);
        // 將最后一位置空沛膳，幫助 GC
        es[size = newSize] = null;
    }

boolean remove(Object o) 移除首個(gè)為o的元素扔枫，返回是否移除

    public boolean remove(Object o) {
        final Object[] es = elementData;
        final int size = this.size;
        // 用于標(biāo)記找到的第一個(gè) o 的位置
        int i = 0;
        found: { // 利用break終止代碼塊執(zhí)行，使代碼更簡(jiǎn)潔
            // 如果 o 是 null
            if (o == null) {
                for (; i < size; i++)
                    if (es[i] == null)
                        break found;
            // 如果 o 不是 null
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))
                        break found;
            }
            return false;
        }
        // 移除
        fastRemove(es, i);
        return true;
    }

4.5 移除多個(gè)元素

boolean removeAll(Collection<?> c) 如果元素在集合 c 中就移除

    /**
     * 刪除多個(gè)元素
     */
    public boolean removeAll(Collection<?> c) {
        // 調(diào)用了批量刪除方法
        return batchRemove(c, false, 0, size);
    }

boolean batchRemove(Collection<?> c, boolean complement, final int from, final int end) 批量移除或保留元素

這個(gè)方法有點(diǎn)繞锹安。先來看參數(shù) complement短荐，它表示如果一個(gè)元素在集合c中，他是保留還是刪除叹哭。結(jié)合另一個(gè)方法
public boolean retainAll(Collection<?> c) { return batchRemove(c, true, 0, size); }
就很容易理解了忍宋，當(dāng)complement為false時(shí)，是移除的邏輯风罩。而為true時(shí)讶踪，是求兩個(gè)集合的交集。

這個(gè)方法的大致邏輯是：（以移除為例）先找到第一個(gè)要移除的元素索引泊交，記為w乳讥，它的下一位記為r。然后從r的位置開始遍歷廓俭，如果是要?jiǎng)h除的元素就跳過云石，如果是要保留的元素，就將它寫到w指向的位置研乒，覆蓋之前的元素汹忠，再把w挪向下一位，繼續(xù)遍歷判斷。最后再把數(shù)組末尾無用的元素置為null宽菜。下文代碼后我貼了一張手繪圖谣膳，可以結(jié)合起來理解∏ο纾或者debug調(diào)試幾次继谚。

/**
     * 批量刪除或保留多個(gè)元素
     * @param c 要?jiǎng)h除的元素集合
     * @param complement 如果一個(gè)元素再 c 中，是刪除還是保留
     * @param from 開始位置
     * @param end 結(jié)束位置
     * @return
     */
    boolean batchRemove(Collection<?> c, boolean complement,
                        final int from, final int end) {
        // 校驗(yàn) c 不是 null
        Objects.requireNonNull(c);
        final Object[] es = elementData;
        int r;
        // Optimize for initial run of survivor 優(yōu)化
        // 想在刪除邏輯前線判斷elementData中到底有沒有 c 中的元素阵幸，但有不想重復(fù)遍歷
        // 這里做的是 找到第一個(gè)不符合 complement 的元素的位置 r 花履，然后結(jié)束遍歷
        for (r = from;; r++) {
            if (r == end)
                return false;
            if (c.contains(es[r]) != complement)
                break;
        }
        // w 標(biāo)記 r 的位置，r + 1 指向下一個(gè)位置
        int w = r++; // 注意挚赊，這里等價(jià)于 w = r; r = r + 1; (i++ 和 ++i 的區(qū)別）
        try {
            for (Object e; r < end; r++)
                // 如果 r 位置的元素符合 complement 诡壁，將 r 位置的元素寫入 w 位置的元素，w 向后挪一位
                // 如果不符合荠割，w 不動(dòng)妹卿，進(jìn)行下次循環(huán)
                if (c.contains(e = es[r]) == complement)
                    es[w++] = e;
        } catch (Throwable ex) {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            // 如果 cntains()方法拋出異常，則將 r 位置后的數(shù)據(jù)寫到 w 位置后
            // 這樣我們剩余沒有遍歷的元素挪過去之后覆蓋了跳過的元素蔑鹦，保證數(shù)組中不會(huì)多出來一些奇怪的元素
            System.arraycopy(es, r, es, w, end - r);
            w += end - r;
            // 把異常繼續(xù)拋出去
            throw ex;
        } finally {
            // 增加修改次數(shù)
            modCount += end - w;
            // 尾部無用元素賦值為null
            shiftTailOverGap(es, w, end);
        }
        return true;
    }
    
    /**
     * 在數(shù)組 hi 和 lo 的位置各剪一刀纽帖，丟掉 hi 和 lo 中間的部分，然后把 hi 這一頭和 
     * lo 那一頭連起來
     * 
     * @param es 數(shù)組
     * @param lo 開始位置
     * @param hi 結(jié)束位置
     */
    private void shiftTailOverGap(Object[] es, int lo, int hi) {
        // 從 hi 位置開始的元素移動(dòng)到 lo 位置后
        System.arraycopy(es, hi, es, lo, size - hi);
        // 將末尾沒用的位置置空
        for (int to = size, i = (size -= hi - lo); i < to; i++)
            es[i] = null;
    }

批量移除元素的大致執(zhí)行過程

批量移除給定范圍內(nèi)的多個(gè)元素 void removeRange(int fromIndex, int toIndex)

    /**
     * 批量移除 [fromIndex, toIndex) （前閉后開）范圍內(nèi)的多個(gè)元素
     */
    protected void removeRange(int fromIndex, int toIndex) {
        // 參數(shù)不正確
        if (fromIndex > toIndex) {
            throw new IndexOutOfBoundsException(
                    outOfBoundsMsg(fromIndex, toIndex));
        }
        // 修改次數(shù)+1
        modCount++;
        // 該方法見上文
        shiftTailOverGap(elementData, fromIndex, toIndex);
    }

根據(jù)條件移除元素 boolean removeIf(Predicate<? super E> filter)

略...

4.6 查找單個(gè)元素

int indexOf(Object o) 查找第一個(gè)指定元素的索引

    public int indexOf(Object o) {
        return indexOfRange(o, 0, size);
    }

    int indexOfRange(Object o, int start, int end) {
        Object[] es = elementData;
        // o 為null的情況
        if (o == null) {
            for (int i = start; i < end; i++) {
                if (es[i] == null) {
                    return i;
                }
            }
        // o 不為null的情況
        } else {
            for (int i = start; i < end; i++) {
                if (o.equals(es[i])) {
                    return i;
                }
            }
        }
        // 沒找到返回 -1
        return -1;
    }

int indexOf(Object o) 查找最后一個(gè)指定元素的索引

    public int lastIndexOf(Object o) {
        return lastIndexOfRange(o, 0, size);
    }

    int lastIndexOfRange(Object o, int start, int end) {
        Object[] es = elementData;
        if (o == null) {
            for (int i = end - 1; i >= start; i--) { // 倒序
                if (es[i] == null) {
                    return i;
                }
            }
        } else {
            for (int i = end - 1; i >= start; i--) {
                if (o.equals(es[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

int indexOf(Object o) 獲得指定位置的元素

    public E get(int index) {
        // 校驗(yàn)
        Objects.checkIndex(index, size);
        return elementData(index);
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }

4.7 設(shè)置指定位置的元素

E set(int index, E element)

    public E set(int index, E element) {
        // 校驗(yàn)
        Objects.checkIndex(index, size);
        // 記錄舊值
        E oldValue = elementData(index);
        // 賦值新值
        elementData[index] = element;
        // 返回舊值
        return oldValue;
    }

5 其他方法

5.1 轉(zhuǎn)換為數(shù)組

Object[] toArray() 轉(zhuǎn)換為Object[]

    // ArrayList.java
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
    
    // Arrays.java
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

Object[] toArray() 轉(zhuǎn)換為給定泛型的數(shù)組

    public <T> T[] toArray(T[] a) {
        // 如果傳入的數(shù)組大小沒有 size 大
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            // 直接復(fù)制一個(gè)新數(shù)組返回
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        // 把 elementData 的數(shù)據(jù)復(fù)制到 a 中
        System.arraycopy(elementData, 0, a, 0, size);
        // 如果 a 的長(zhǎng)度 大于 size 举反，就懊直。。把 size 位置設(shè)置為 null 火鼻？室囊？？
        if (a.length > size)
            a[size] = null;
        return a;
    }

對(duì)中間a[size] = null的疑惑作者在方法注釋中有寫到：

     * <p>If the list fits in the specified array with room to spare
     * (i.e., the array has more elements than the list), the element in
     * the array immediately following the end of the collection is set to
     * {@code null}.  (This is useful in determining the length of the
     * list <i>only</i> if the caller knows that the list does not contain
     * any null elements.)

如果調(diào)用者明確知道數(shù)組中沒有空元素魁索，那么這對(duì)于確定list的length很有幫助融撞。emmm...插入null值作為一個(gè)標(biāo)記..或許調(diào)用者可以在遍歷數(shù)組時(shí)判斷元素為空就不再遍歷了？粗蔚？

5.2 求哈希值

int hashCode()

    public int hashCode() {
        // 記錄開始前數(shù)組修改次數(shù)
        int expectedModCount = modCount;
        // 獲取哈希值
        int hash = hashCodeRange(0, size);
        // 并發(fā)修改校驗(yàn)
        checkForComodification(expectedModCount);
        return hash;
    }

    int hashCodeRange(int from, int to) {
        final Object[] es = elementData;
        // 校驗(yàn)
        if (to > es.length) {
            throw new ConcurrentModificationException();
        }
        // 計(jì)算hash值
        int hashCode = 1;
        for (int i = from; i < to; i++) {
            Object e = es[i];
            // 為什么要乘31尝偎，看下文參考資料
            hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
        }
        return hashCode;
    }
    
    /**
     * 并發(fā)修改校驗(yàn)，如果操作前數(shù)組的修改次數(shù)和操作后的修改次數(shù)不一致鹏控，
     * 則拋出異常
     */
    private void checkForComodification(final int expectedModCount) {
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

參考資料：田小波的技術(shù)博客——科普：String hashCode 方法為什么選擇數(shù)字31作為乘子

5.3 判斷相等

boolean equals(Object o)

    public boolean equals(Object o) {
        // 與自己本身相比致扯，直接返回 true
        if (o == this) {
            return true;
        }

        // 非 List 類型，直接返回 false
        if (!(o instanceof List)) {
            return false;
        }

        // 記錄當(dāng)前數(shù)組修改次數(shù)
        final int expectedModCount = modCount;
        // ArrayList can be subclassed and given arbitrary behavior, but we can
        // still deal with the common case where o is ArrayList precisely
        // 根據(jù)類型是否是ArrayList当辐，選擇不同的比較方式
        // ArrayList可以遍歷數(shù)組抖僵，性能更優(yōu)，而其他List只能用迭代器缘揪。
        boolean equal = (o.getClass() == ArrayList.class)
            ? equalsArrayList((ArrayList<?>) o)
            : equalsRange((List<?>) o, 0, size);
        // 并發(fā)修改校驗(yàn)
        checkForComodification(expectedModCount);
        return equal;
    }
    
    private boolean equalsArrayList(ArrayList<?> other) {
        // 記錄傳入list的修改次數(shù)
        final int otherModCount = other.modCount;
        final int s = size;
        boolean equal;
        // 先判斷 size 是否相等
        if (equal = (s == other.size)) {
            final Object[] otherEs = other.elementData;
            final Object[] es = elementData;
            // 校驗(yàn)并發(fā)修改
            if (s > es.length || s > otherEs.length) {
                throw new ConcurrentModificationException();
            }
            // 遍歷耍群，比較每個(gè)對(duì)應(yīng)元素是否相等
            for (int i = 0; i < s; i++) {
                if (!Objects.equals(es[i], otherEs[i])) {
                    equal = false; // 如果不相等跳出循環(huán)
                    break;
                }
            }
        }
        // 校驗(yàn)傳入list的并發(fā)修改
        other.checkForComodification(otherModCount);
        return equal;
    }
    
    boolean equalsRange(List<?> other, int from, int to) {
        final Object[] es = elementData;
        // 并發(fā)修改校驗(yàn)
        if (to > es.length) {
            throw new ConcurrentModificationException();
        }
        // 用迭代器遍歷逐個(gè)對(duì)比
        var oit = other.iterator();
        for (; from < to; from++) {
            // 如果oit沒有下一個(gè)元素或當(dāng)前元素不相等义桂，直接返回 false
            if (!oit.hasNext() || !Objects.equals(es[from], oit.next())) {
                return false;
            }
        }
        // 返回oit是否還有剩余的元素。如果還有當(dāng)然是不相等的
        return !oit.hasNext();
    }

5.4 克隆

Object clone()

    public Object clone() {
        try {
            // 調(diào)用父類克隆方法
            ArrayList<?> v = (ArrayList<?>) super.clone();
            // 拷貝新數(shù)組
            v.elementData = Arrays.copyOf(elementData, size);
            // 修改次數(shù)置為 0
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            // 實(shí)現(xiàn)Cloneable接口后不會(huì)再發(fā)生了
            throw new InternalError(e); // JVM 意外內(nèi)部錯(cuò)誤
        }
    }

5.5 清空

void clear()

    public void clear() {
        // 修改次數(shù) + 1
        modCount++;
        // 遍歷置空 倒序
        final Object[] es = elementData;
        for (int to = size, i = size = 0; i < to; i++)
            es[i] = null;
    }

5.6 序列化與反序列化

void writeObject(java.io.ObjectOutputStream s) 序列化

    @java.io.Serial
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        int expectedModCount = modCount;
        // 序列化 非靜態(tài)蹈垢，非 transient 屬性
        s.defaultWriteObject();

        // 寫入 size 慷吊，為了兼容 clone() 方法 ？曹抬？溉瓶？
        s.writeInt(size);

        // Write out all elements in the proper order.
        // 逐個(gè)寫入元素
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        // 并發(fā)修改校驗(yàn)
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

elementData是加了transient關(guān)鍵字的，序列化時(shí)會(huì)只序列化size大小的真實(shí)使用的數(shù)組沐祷，不會(huì)序列化elementData預(yù)留出的那一部分嚷闭。節(jié)省時(shí)間和空間攒岛。

void readObject(java.io.ObjectOutputStream s)

    @java.io.Serial
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {

        // 反序列化 非靜態(tài)赖临，非 transient 屬性
        s.defaultReadObject();

        // Read in capacity
        // 讀取 size ，但忽略不用了
        s.readInt(); // ignored

        if (size > 0) {
            // like clone(), allocate array based upon size not capacity
            // emmm....
            SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
            Object[] elements = new Object[size];

            // 逐個(gè)讀取元素
            for (int i = 0; i < size; i++) {
                elements[i] = s.readObject();
            }

            elementData = elements;
        } else if (size == 0) {
            // size 是 0 的話使用空數(shù)組
            elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new java.io.InvalidObjectException("Invalid size: " + size);
        }
    }

6 End

省略了一些不常用的或簡(jiǎn)單的方法灾锯，以及邏輯重點(diǎn)不在ArrayList中的方法（比如sort()排序）兢榨。