java的ArrayList源碼解析

前言

本篇主要討論ArrayList集合，本人使用的jdk1.8

正文

成員變量

1. 默認初始化容量（未指定容量，而且要在調用add方法時纔會用）
2. 當ArrayList初始化時顯示指定容量爲0時的初始化數據
3. 當ArrayList初始化時未顯示指定容量時的初始化數據
4. ArrayList中存取數據的數組
5. 數組中實際存儲數據的大小，也就是ArrayList中實際存儲的數量,初始化時size爲0；
6. ArrayList中數組容量的最大值

構造方法

ArrayList有三個構造方法；

• 初始化時顯示指定容量

當顯示指定容量爲0時，使用EMPTY_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);
        }
    }
複製代碼

• 初始化時未指定容量

未顯示指定數組容量時，使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
複製代碼

• 將其餘集合類轉爲ArrayList

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;
        }
    }
複製代碼

經常使用的方法

add()方法

向ArrayList中添加元素；add方法有兩種方式

• 直接添加數據，不指定位置

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

該方法直接將數據存儲到了數組的末尾，而且size會自增1，在增長數據以前會調用ensureCapacityInternal方法對數組容量進行校驗，也就是自動擴容；擴容留到後邊講；

• 添加數據，並指定數據存儲的位置

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++;
    }
複製代碼

將數據存入數組指定位置，首先會調用rangeCheckForAdd檢查index是否越界，而後就是ensureCapacityInternal方法進行擴容校驗，而後在調用System.arraycopy方法對原數組進行復制，將數組從下標爲index到結尾的全部數據總體向後移一位，這個方法是很耗費內存的（我百度看到的博客基本上都是這麼說的），這時候下標爲index的那段空間就爲空了，而後再將element插入數組中的指定位置；

System.arraycopy方法圖以下：

remove()方法

刪除ArrayList中的元素；remove方法也有兩種方式

• 根據下標刪除

public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        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
        return oldValue;
    }
複製代碼

rangeCheck方法檢查index是否越界;能夠看出最後就是調用System.arraycopy方法來複制數組，將下標以後的全部元素向前移一位，而後size再自減;而且清空最後的元素，最後返回刪除的元素；

• 傳入元素刪除數據

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;
    }
複製代碼

根據傳入的數據來刪除數組中的元素：

1. 當傳入須要刪除的元素爲空時，首先會查找到第一個元素爲`null`的下標，而後調用`fastRemove`方法刪除元素；其中`fastRemove`方法與`remove(int index)`方法是同樣的，只是沒有返回值，這裏就不貼代碼了；
          2. 當傳入`Object`不爲`null`時，會循環數組，找到`o.equals(elementData[index])`爲true時的元素的第一個下標，而後調用`fastRemove`來刪除元素
複製代碼

注意，都是刪除的第一個相同的元素，後面的就不會管了；

現象：在纔開始使用ArrayList的時候，用for循環來刪除ArrayList中符合某一規則的元素，若是兩個相同元素在連續的位置上，會出現不能所有刪除現象，其實這是對ArrayList的remove方法的源碼不熟了；

remove方法是將數組複製了一遍，產生了新的數組，這時數組裏面元素的下標都改變了，這時for循環並無改變接着向後循環，因此相鄰的一個元素就沒法刪除；

get()方法

獲取ArrayList中的元素

就一種方式；根據下標獲取元素

public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
複製代碼

先調用rangeCheck檢查下標是否越界,在獲取元素

set()方法

修改ArrayList中額元素；

也是就一種方式：根據傳入的下標及元素來修改

public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
複製代碼

首先調用rangeCheck檢查下標是否越界，獲取下標元素值，而後再用傳入的元素替換掉原來的元素；最後返回原來的元素；

size()方法

public int size() {
        return size;
    }
複製代碼

獲取ArrayList中實際使用的容量；不是數組容量；

數組容量自動增加

咱們在使用ArrayList的時候都是調用add方法來添加元素，可是咱們知道ArrayList是使用的數組來存儲元素，而數組是有長度，爲何咱們使用add方法能夠一直添加元素且不會報錯？

代碼以下：

// 1
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
    //2
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //3
    private void grow(int minCapacity) {
        // overflow-conscious code
        //3.1
        int oldCapacity = elementData.length;
        //3.2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //3.3
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //3.4
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //3.5
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
複製代碼

擴容使用到了四個方法

1. ensureCapacityInternal方法主要是判斷若是當前ArrayList是默認未指定容量的初始化時，而後選取minCapacity與DEFAULT_CAPACITY中的最大值賦予minCapacity，再傳入下一個方法；

2. ensureExplicitCapacity方法接受minCapacity參數，判斷下標是否超過當前數組的容量，若是超過則調用grow方法，未超過則不調用；

3. grow方法就是擴容的主要方法，選取擴容的值；

   3.1 首先獲取原來數組的長度oldCapacity;

   3.2 進行擴容計算，代碼中使用了位運算，增長的那部分爲oldCapacity向右移一位的值，其實就是一半；

   3.3 判斷擴容後是否知足minCapacity值

   3.4 判斷擴容後的newCapacity是否超過ArrayList容許的最大值，若是超過就用最大值替換

   3.5 調用Arrays.copyOf對數組進行擴容;

迭代器

代碼以下：

//1
    public Iterator<E> iterator() {
        return new Itr();
    }
    //2
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
        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;
            return (E) elementData[lastRet = i];
        }
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
       
    }
複製代碼

主要說Itr類中的三個變量及三個方法

三個變量：

1. cursor ：初始值爲零，返回下一個元素的索引
2. lastRet：返回的最後一個元素的索引；若是沒有，則爲-1
3. expectedModCount ：略

三個方法：

1. hasNext方法，判斷cursor是否與size相等；就至關於判斷下標是否越界；
2. next方法：獲取下標爲cursor 的元素，且cursor自增1
3. remove方法：調用了ArrayList中的remove方法刪除下標爲lastRet的元素，且cursor變爲lastRet的值，這就解決了兩個連續元素不能刪除的現象了；

總結

• 容器底層採用數組存儲，申請內存爲連續空間，每次擴容爲1.5倍
• ArrayList的實現中大量調用了 Arrays.copyof()和System.arraycopy()方法，其實Arrays.copyof()內部也是調用System.arraycopy()。System.arraycopy()爲Native方法
• ArrayList隨機元素時間複雜度O(1)，插入刪除操做需大量移動元素，效率較低
• ArrayList能夠存儲null值
• ArrayList線程是不安全的
• 對ArrayList進行選擇刪除時，不能用for循環（ArrayList刪除方法調用的System.arraycopy()這個方法，生成的是一個新的數組，下標也已經改變了）,建議用迭代器進行刪除。