前言

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

正文

成員變量

默認初始化容量（未指定容量，並且要在調用add方法時纔會用）
當ArrayList初始化時顯示指定容量爲0時的初始化數據
當ArrayList初始化時未顯示指定容量時的初始化數據
ArrayList中存取數據的數組
數組中實際存儲數據的大小
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);
    }

擴容使用到了四個方法

ensureCapacityInternal方法主要是判斷如果當前ArrayList是默認未指定容量的初始化時，然後選取minCapacity與DEFAULT_CAPACITY中的最大值賦予minCapacity，再傳入下一個方法；
ensureExplicitCapacity方法接受minCapacity參數，判斷下標是否超過當前數組的容量，如果超過則調用grow方法，未超過則不調用；
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類中的三個變量及三個方法

三個變量：

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

三個方法：

hasNext方法，判斷cursor是否與size相等；就相當於判斷下標是否越界；
next方法：獲取下標爲cursor 的元素，且cursor自增1
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()這個方法，生成的是一個新的數組，下標也已經改變了）,建議用迭代器進行刪除。

ArrayList源碼解析

前言

正文

成員變量

構造方法

常用的方法

add()方法

remove()方法

get()方法

set()方法

size()方法

數組容量自動增長

迭代器

總結

Lombok builder 繼承屬性

MethodInterceptor 的幾種用法（二）

記一次idea快捷鍵

springboot異步線程（一）

ThreadLocal源碼閱讀

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結