源碼分析之ArrayList

時間  2019-11-16
標籤 源碼 分析 arraylist 欄目 Java 简体版
原文   原文鏈接

概念

ArrayList是咱們經常使用的集合類，是基於數組實現的。不一樣於數組的是ArrayList能夠動態擴容。java

類結構

ArrayList是Java集合框架List接口的一個實現類。提供了一些操做數組元素的方法。數組

實現List接口同時，也實現了 RandomAccess, Cloneable, java.io.Serializable。安全

ArrayList繼承與AbstractList。多線程

ArrayList類圖

類成員

elementData

transient Object[] elementData;複製代碼

elementData是用於保存數據的數組，是ArrayList類的基礎。併發

elementData是被關鍵字transient修飾的。咱們知道被transient修飾的變量，是不會參與對象序列化和反序列化操做的。而咱們知道ArrayList實現了java.io.Serializable，這就代表ArrayList是可序列化的類，這裏貌似出現了矛盾。框架

ArrayList在序列化和反序列化的過程當中，有兩個值得關注的方法：writeObject和 readObject：dom

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order. 
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

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

    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity 
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }複製代碼

writeObject會將ArrayList中的size和element數據寫入ObjectOutputStream。readObject會從ObjectInputStream讀取size和element數據。ide

之因此採用這種序列化方式，是出於性能的考量。由於ArrayList中elementData數組在add元素的過程，容量不夠時會動態擴容，這就到可能會有空間沒有存儲元素。採用上述序列化方式，能夠保證只序列化有實際值的數組元素，從而節約時間和空間。函數

size

private int size;複製代碼

size是ArrayList的大小。性能

DEFAULT_CAPACITY

/** * Default initial capacity. */
    private static final int DEFAULT_CAPACITY = 10;複製代碼

ArrayList默認容量是10。

構造函數

ArrayList提供了2個構造函數ArrayList(int initialCapacity)和 ArrayList()。

使用有參構造函數初始化ArrayList須要指定初始容量大小，不然採用默認值10。

add()方法

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

在add元素以前，會調用ensureCapacityInternal方法，來判斷當前數組是否須要擴容。

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 若是elementData爲空數組，指定elementData最少須要多少容量。
            // 若是初次add，將取默認值10；
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        // elementData容量不足的狀況下進行擴容
        if (minCapacity - elementData.length > 0)
            grow(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);
    }複製代碼

  • 從grow方法中能夠看出，ArrayList的elementData數組如遇到容量不足時，將會把新容量newCapacity設置爲 oldCapacity + (oldCapacity >> 1)。二進制位操做>> 1等同於/2的效果，擴容致使的newCapacity也就設置爲原先的1.5倍。

  • 若是新的容量大於MAX_ARRAY_SIZE。將會調用hugeCapacity將int的最大值賦給newCapacity。不過這種狀況通常不會用到，不多會用到這麼大的ArrayList。

在確保有容量的狀況下，會將元素添加至elementData數組中。

add(int index, E element) 方法

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

帶有index的add方法相對於直接add元素方法會略有不一樣。

  • 首先會調用rangeCheckForAdd來檢查，要添加的index是否存在數組越界問題；
  • 一樣會調用ensureCapacityInternal來保證容量；
  • 調用System.arraycopy方法複製數組，空出elementData[index]的位置；
  • 賦值並增長size；

remove(int index) 方法

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

ArryList提供了兩個刪除List元素的方法，如上所示，就是根據index來刪除元素。

  • 檢查index是否越界；
  • 取出原先值的，若是要刪除的值不是數組最後一位，調用System.arraycopy方法將待刪除的元素移動至elementData最後一位。
  • 將elementData最後一位賦值爲null。

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

remove(Object o)是根據元素刪除的，相對來講就要麻煩一點：

  • 當元素o爲空的時候，遍歷數組刪除空的元素。
  • 當元素o不爲空的時候，遍歷數組找出於o元素的index，並刪除元素。
  • 若是以上兩步都沒有成功刪除元素，返回false。

modCount

在add、remove過程當中，常常發現會有modCount++或者modCount--操做。這裏來看下modCount是個啥玩意。

modCount變量是在AbstractList中定義的。

protected transient int modCount = 0;複製代碼

modCount是一個int型變量，用來記錄ArrayList結構變化的次數。

modCount起做用的地方是在使用iterator的時候。ArrayList的iterator方法。

public Iterator<E> iterator() {
        return new Itr();
    }

     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();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

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

iterator方法會返回私有內部類Itr的一個實例。這裏能夠看到Itr類中不少方法，都會調用checkForComodification方法。來檢查modCount是夠等於expectedModCount。若是發現modCount != expectedModCount將會拋出ConcurrentModificationException異常。

這裏寫一個小例子來驗證體會下modCount的做用。簡單介紹一下這個小例子：準備兩個線程t1、t2，兩個線程對同一個ArrayList進行操做，t1線程將循環向ArrayList中添加元素，t2線程將把ArrayList元素讀出來。

Test類：

public class Test {

    List<String> list = new ArrayList<String>();


    public Test() {

    }


    public void add() {

        for (int i = 0; i < 10000; i++) {
            list.add(String.valueOf(i));
        }

    }

    public void read() {

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }複製代碼

t1線程：

public class Test1Thread implements Runnable {

    private Test test;

    public Test1Thread(Test test) {
        this.test = test;
    }

    public void run() {

        test.add();

    }複製代碼

t2線程：

public class Test2Thread implements Runnable {

    private Test test;

    public Test2Thread(Test test) {
        this.test = test;
    }


    public void run() {
        test.read();
    }
}複製代碼

main類

public static void main(String[] args) throws InterruptedException {

        Test test = new Test();
        Thread t1  = new Thread(new Test1Thread(test));
        Thread t2  = new Thread(new Test2Thread(test));

        t1.start();
        t2.start();

    }複製代碼

執行這個mian類就會發現程序將拋出一個ConcurrentModificationException異常。

由異常能夠發現拋出異常點正處於在調用next方法的checkForComodification方法出現了異常。這裏也就出現上文描述的modCount != expectedModCount的狀況，緣由是t2線程在讀數據的時候，t1線程還在不斷的添加元素。

這裏modCount的做用也就顯而易見了，用modCount來規避多線程中併發的問題。由此也能夠看出ArrayList是非線程安全的類。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程