ArrayList源碼分析jdk1.8版本

ArrayList感覺是在做項目中遇到最多的，先從添加元素開始講起，請跟隨我的思路
1.add(E e)，最常用的，其他添加元素的方法和這個方法的實現都差不多

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

在添加元素之前，所有方法都會進行一次檢查，是否需要進行擴容，如果在指定位置添加元素，則會調用rangeCheckForAdd(index)對index進行檢查，是否越界
重點看一下ensureCapacityInternal(size + 1)方法

 private void ensureCapacityInternal(int minCapacity) {
        //這個判斷是針對默認構造函數
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //在小于10之前最大值一直都是DEFAULT_CAPACITY
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

為什么說那個if判斷是針對默認構造函數的呢

默認構造函數：

 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

而Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
其實默認構造函數并沒有對elementData進行初始化
而非默認構造函數，比如：

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

是直接對elementData進行了一個初始化的
ensureCapacityInternal(int minCapacity)方法會調用ensureExplicitCapacity(minCapacity)方法

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

modCount記錄的是對數據結構進行修改的次數
如果添加了一個數組元素以后會導致數組溢出，就會進行擴容，真正進行擴容操作的是grow()函數

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
       //擴大為原來的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //超過容器允許的最大值
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 進行數組拷貝
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

所以對于調用默認構造函數時，數組的初始化是在第一次添加元素的時候調用grow()函數進行初始化的，對于已經初始化的容器，擴容以后擴大為原容器的1.5倍，而對于沒有進行初始化的容器（即調用默認構造函數）初始化為10。如果擴容以后超過最大值將調用hugeCapacity(int minCapacity)方法

 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

超過最大值以后（擴容1.5被），則只能擴容為最大值的大小

還是有必要講講 add(int index, E element)方法的，因為這里暴露出了ArrayList的缺陷

public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

有些方法和add(E e)相同，就不累述了。在指定位置上添加元素時，會進行數組拷貝
2.get(int index)

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

        return elementData(index);
    }

方法非常簡單易懂，不多說，因為是基于數組查找到所需元素，查找速度非常快

3.remove(int index)也是一個非常基本的方法

public E remove(int index) {
        //越界檢查
        rangeCheck(index);
       //會對表結構進行修改，modCount進行加1操作
        modCount++;
        //獲得指定位置上的元素
        E oldValue = elementData(index);
       //因為移除一個元素以后會對數組位置進行移動，這里計算了需
      要移動的距離
        int numMoved = size - index - 1;
        //數組的拷貝
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
       //標記為null，不可達，讓垃圾收集器進行回收
        elementData[--size] = null; 
        //返回舊值
        return oldValue;
    }

因為remove操作會修改數組的結構，所以會對modCount進行加1操作。數組上的刪除操作是非常慢的，因為需要進行數組拷貝。所以ArrayList適合讀多寫少的場景

remove(Object o)方法

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

這個方法就是首先找到o元素在數組中的位置，然后調用fastRemove(index)移除指定位置上的元素

private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

為什么是fastRemove呢，就是少了一次對index的check，得瑟死了。因為你在數組中找到那個元素的位置肯定是合法的，所以不需要進行檢查
從這里也可以看出，ArrayList中可以添加null值，寫個測試demo
AddNull.java

public class AddNull {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(null);
        System.out.println("size: " + arrayList.size());
        Object o = arrayList.get(0);
        System.out.println("o: " + o);
    }
}

運行結果：

size: 1
o: null

果然添加成功了

4.對ArrayList集合進行不正確操作可能引起的fail-fast
什么是fail-fast:
java集合中的一種錯誤機制。當多個線程對同一個集合的內容進行操作時，就可能會產生fail-fast事件。例如：當某一個線程A通過iterator去遍歷某集合的過程中，若該集合的結構被其他線程所改變了，那么線程A訪問集合時，就會拋出
ConcurrentModificationException異常，產生fail-fast事件
測試代碼：TestFailFast.java

public class TestFailFast {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        System.out.println("沒刪除元素之前進行一次遍歷");
        for (String s: list) {
            System.out.println(s);
        }

        //使用foreach就相當于使用迭代器
//        for (String s : list) {
//            if (s.equals("B")) {
//                list.remove(s);
//            }
//        }


        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            if (s.equals("B")) {
                list.remove(s);  
            }
        }

        //刪除B元素進行一次遍歷
        System.out.println("刪除B元素以后進行一次遍歷");
        for (String s: list) {
            System.out.println(s);
        }
    }
}

程序運行結果：

沒刪除元素之前進行一次遍歷
Exception in thread "main" java.util.ConcurrentModificationException
A
B
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
C
D
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at TestFailFast.main(TestFailFast.java:32)

而對內容的修改是不會引起fail-fast的，對上述代碼進行了修改，修改的部分代碼如下：

Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            if (s.equals("B")) {
                list.set(1, "test");  //該方法只適用于remove方法，且是在單線程環境下
            }
        }

程序運行結果：

沒刪除元素之前進行一次遍歷
A
B
C
D
刪除B元素以后進行一次遍歷
A
test
C
D

沒有引起fail-fast

出現fail-fast的源碼分析：
出現這個問題的原因是迭代器Iterator，Iterator是一個接口，ArrayList中Itr類實現了這個接口，這個類中的一個next()方法

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;
            return (E) elementData[lastRet = i];
        }

調用next()方法時會進行一次核對，即調用 checkForComodification()方法，這個方法中將會拋出異常

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

當modCount != expectedModCount不等時就會拋出異常，而Itr類中的expectedModCount值等于集合未發生修改時的modCount值，Itr類中的代碼：int expectedModCount = modCount;
如果此時你對集合的結構（比如調用了add(xxx)、remove(xxx)這類方法）進行了修改引起了modCount的變化，就會使兩個值不相等，當調用迭代器的next()方法時就會拋出異常
在單線程的情況下，可以通過調用迭代器的remove()或add(E e)方法，對集合的結構進行修改，因為此時expectedModCount會被重新賦值，以remove()方法為例：

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

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

AbstractList.this.remove(lastRet)方法會調用集合的add方法
expectedModCount = modCount;重新賦值
但是這個方法有個缺陷，只適合在單線程下，多線程下避免這種情況應該使用CopyOnWriteArrayList

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 228,923評論 6贊 535
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,740評論 3贊 420
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 176,856評論 0贊 380
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,175評論 1贊 315
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,931評論 6贊 410
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,321評論 1贊 324
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,383評論 3贊 443
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,533評論 0贊 289
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,082評論 1贊 335
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,891評論 3贊 356
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,067評論 1贊 371
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,618評論 5贊 362
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,319評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,732評論 0贊 27
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 35,987評論 1贊 289
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,794評論 3贊 394
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,076評論 2贊 375