前期自己對于源碼解析，以為看過既可以闽晦，然后就是類似翻譯的動作而已匪蟀。后期發(fā)現(xiàn)這種形式并沒有什么好的。所以需要重新思考闻蛀。
看源碼前的準(zhǔn)備匪傍。

1.ArrayList是什么

首先根據(jù)如下圖：

ArrayList類圖

1.最頂級接口Iterable，這個是迭代器模式的頂級接口觉痛，忽略
2.Collection接口役衡，這個就是集合類的頂級接口了
3.List接口，列表類頂級接口薪棒，于set集合區(qū)分
4.RandomAccess接口手蝎，是一個標(biāo)記接口。表明當(dāng)前類可以進行快速隨機訪問俐芯。忽略
5.Cloneable接口棵介，標(biāo)記接口。表明深拷貝泼各。忽略
6.其他的序列化接口鞍时，和集合的抽象實現(xiàn)，列表的抽象實現(xiàn)扣蜻。
所以從ArrayList的類圖可以看出逆巍，ArrayList就是一個集合類。且是一個列表集合莽使，即支持可重復(fù)的集合元素锐极。

2.ArrayList能干什么

通過前面的分析，知道ArrayList是一個列表集合的具體實現(xiàn)芳肌。那么列表集合能干什么呢灵再。最基礎(chǔ)的應(yīng)用就是存儲。將數(shù)據(jù)存儲到內(nèi)存中亿笤。且存儲的內(nèi)容是按照存入的先后順序進行存儲的翎迁。

3.分析準(zhǔn)備

在進行ArrayList分析之前，ArrayList是什么净薛，能干什么我們已經(jīng)很清楚了汪榔。那么首先我們自己先分析下，如果自己去寫一個集合都需要干什么呢肃拜。

3.1類比

這種分析一般都是需要對照到生活中的例子進行類比分析痴腌，然后進行代碼實現(xiàn)雌团，才能更好的理解類。首先集合類似于我們生活中的倉庫士聪。

3.2操作

既然是倉庫那么就需要存儲貨物锦援。而存儲貨物的時候最基本的操作。
1.入庫
2.出庫
3.清點貨物總數(shù)
4.查看貨物

3.3自己實現(xiàn)

根據(jù)自己的思路實現(xiàn)一個ArrayList

package com.jiyx.test.collect;

/**
 *
 * auther: jiyx
 * date: 2019-05-02
 */
public class MyArrayList {

    private Object[] items = new Object[64];

    private int currIndex;

    /**
     * 入庫
     * @param item
     */
    public void add(Object item) {
        rangeCheckOut(currIndex);
        items[currIndex++] = item;
    }

    /**
     * 查看剥悟，不出庫
     * @param index
     * @return
     */
    public Object get(int index) {
        rangeCheckOut(index);
        return items[index];
    }

    /**
     * 出庫
     * @param index
     * @return
     */
    public Object remove(int index) {
        rangeCheckOut(index);
        Object value = items[index];
        if (items.length - index - 1 > 0) {
            System.arraycopy(items, index + 1, items, index, items.length - index - 1);
        }
        currIndex--;
        return value;
    }

    /**
     * 當(dāng)前存儲的元素個數(shù)
     * @return
     */
    public int size() {
        return currIndex;
    }

    /**
     * 角標(biāo)越界校驗
     * @param currIndex
     */
    private void rangeCheckOut(int currIndex) {
        if (currIndex > items.length - 1) {
            throw new ArrayIndexOutOfBoundsException();
        }
    }

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add(1);
        list.add("aaa");
        list.add(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        list.remove(1);
        list.add("bbb");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

4.分析

好了進入正題灵寺，進行ArrayList源碼淺析。這里ArrayList無非也是上面的幾個操作懦胞，不過可能比我寫的更加完善替久，功能更多而已。
那么同樣的躏尉，還是按照基本功能蚯根，外加一個初始化進行分析。

4.1初始化

因為倉庫是沒有的胀糜，所以我們需要自己手動創(chuàng)建一個倉庫的颅拦。那么new的過程就是創(chuàng)建這個倉庫的過程。
初始化分為三種教藻，無參構(gòu)造距帅、傳入初始容量構(gòu)造器、傳入老的集合的構(gòu)造器括堤。其實初始化的過程很簡單碌秸。可以自行查看悄窃。不過這里有兩個變量需要注意讥电。EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA。因為在創(chuàng)建的過程無參構(gòu)造時需要用到后者轧抗。其他兩個構(gòu)造都是用到了前者恩敌。這兩個雖然值和存在的意義都一樣。區(qū)別是横媚，在第一個元素添加的時候纠炮。前者的第一次擴容為1。而后者的第一次擴容為10灯蝴。

4.1入庫

Arraylist的入庫入口為add方法恢口。重載了兩個方法。

    public boolean add(E e) {
        // 判斷容量是否足夠穷躁，如果不足進行擴容
        ensureCapacityInternal(size + 1);
        // 添加元素
        elementData[size++] = e;
        return true;
    }
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        // 判斷容量是否足夠耕肩，如果不足進行擴容
        ensureCapacityInternal(size + 1);
        // 騰出需要插入元素的位置，也就是將元素后移一位
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        // 添加元素
        elementData[index] = element;
        size++;
    }

而且這里面必須介紹下方法ensureCapacityInternal及其設(shè)計到的方法，都不是很復(fù)雜看疗。如下：

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
     * 計算最小容量
     * @param elementData
     * @param minCapacity
     * @return
     */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    /**
     * 根據(jù)最小容量確認是否需要進行擴容
     * @param minCapacity
     */
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

    /**
     * 具體的擴容操作
     * @param minCapacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

4.2出庫

出庫的動作是由remove完成的。這個也比較簡單了睦授。但是呢两芳，重載了兩個，因為在從倉庫中移除物品的時候去枷〔懒荆可能根據(jù)編號，也可能根據(jù)某個物品删顶。

    public E remove(int index) {
        // 判斷角標(biāo)是否越界
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        // 這塊判斷是否需要進行數(shù)據(jù)遷移竖螃，如果移出的位置在中間，那么需要將后面的物品前移一位
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        // 將最后一位設(shè)置為null
        elementData[--size] = null;

        return oldValue;
    }
    /**
     * 移出逗余，不返回對象特咆。因為我們知道要移出的是哪個對象
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        if (o == null) {
            // 移除null值
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    // 真正的移出數(shù)據(jù)
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                // 對象的移出，是根據(jù)equals進行判斷的录粱，所以對象要重寫這個方法
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    /**
     * 相對于remove(int index)方法腻格，少了角標(biāo)校驗，也沒有返回值
     * 因為調(diào)用方法的也就remove(Object o)啥繁，而他是在循環(huán)遍歷中調(diào)用的菜职，所以這里不做角標(biāo)校驗
     * @param index
     */
    private void fastRemove(int index) {
        // 修改次數(shù)加一
        modCount++;
        
        // 是否需要進行數(shù)據(jù)遷移
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        elementData[--size] = null;
    }

4.3清點貨物總數(shù)

因為一般我們的倉庫管理時，在物品入庫的時候旗闽，會做一個記錄酬核。所以直接查看記錄就知道有多少物品了。

    public int size() {
        return size;
    }

4.4查看貨物

get方法适室，比較簡單

    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

    E elementData(int index) {
        return (E) elementData[index];
    }

4.5其他方法

當(dāng)然了嫡意，ArrayList中還有很多實用的方法。如

    /**
     * 是否包含某對象
     * @param o
     * @return
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 查看對象在倉庫arrayList中的位置
     * @param o
     * @return
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    /**
     * 查找最近入庫的相同的對象
     * @param o
     * @return
     */
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    /**
     * 批量的入庫
     * @param c
     * @return
     */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 從指定位置開始批量入庫
     * @param index
     * @param c
     * @return
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                    numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

5.可修改的問題

1.方法中會出現(xiàn)a-b>0這種代碼亭病。感覺沒有a>b來的清晰明了
2.代碼中存在很多重復(fù)代碼鹅很。如remove(Object o)就是修改為如下

public boolean remove(Object o) {
        for (int index = 0; index < size; index++) {
            if ((o == null && elementData[index] == null) 
                    || (o != null && o.equals(elementData[index]))) {
                fastRemove(index);
                return true;
            }
        }
        return false;
    }