1. 程式人生 > >ArrayList相關方法介紹及原始碼分析

ArrayList相關方法介紹及原始碼分析

目錄

    • ArrayList簡介:
    • ArrayList 相關方法介紹
      • 程式碼表示
      • 相關方法原始碼分析

ArrayList簡介:

java.util.ArrayList 是我們最常用的一個類,ArrayList 底層是動態陣列,讀者可以把它理解為陣列的實現

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{

}

如上程式碼我們可以看到 ArrayList 繼承了 AbstractList() 抽象類,並實現了 List, RandomAccess, Cloneable, Serializable 介面

AbstractList :

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {}

可以看到AbstractList 繼承了 AbstractCollection 介面, 並實現了List 介面

AbstractCollection :

public abstract class AbstractCollection<E> implements Collection<E> {}

AbstractCollection 是一個抽象類,實現了Collection 介面,並提供了某些方法的具體實現。

Collection:

Collection 是一個頂級介面,是很多集合類的頂級介面,繼承了Iterable ,支援輕量級遍歷其中元素

public interface Collection<E> extends Iterable<E> {}

List :

ArrayList 實現了List介面,List 也是一個和Collection 媲美的頂級介面,繼承了Collection 介面

public interface List<E> extends Collection<E> {}

它是許多集合類的父類,

eg:

List list = new ArrayList();
List list2 = new LinkedList();

RandomAccess

RandomAccess 也是一個頂級介面,實現了此介面的類支援隨機訪問

Cloneable

Cloneable 介面是一個頂級介面,實現了此介面的類支援淺拷貝

Serializable

實現此介面的類支援序列化的功能

類之間的繼承關係如圖

ArrayList 相關方法介紹

trimToSize()

程式碼表示

實踐才是檢驗真理最好的方式:

import java.util.*;

/**
 * 詳述ArrayList 基本用法
 */
public class ArrayListTest {

    private static class SortList implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            Integer i1 = Integer.valueOf(o1);
            Integer i2 = Integer.valueOf(o2);
            if(i1 < i2){
                return -1;
            }else if(i1 == i2){
                return 0;
            }
            return 1;
        }
    }

    // 使用可變引數,能夠接受任意個引數
    public Set<String> putSet(String...args){
        Set<String> sets = new HashSet<>();
        for(String str : args){
            sets.add(str);
        }
        return sets;
    }

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");

        // 在指定位置新增元素
        list.add(0,"333");
        System.out.println(list);

        // 進行外部排序
        list.sort(new SortList());
        System.out.println(list);

        list.clear();
        System.out.println(list.size());

        // 使用addAll新增元素
        ArrayListTest at = new ArrayListTest();
        list.addAll(at.putSet("1","2","3"));

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
            // 移除所有元素
            it.remove();
        }

        System.out.println("list是否為空 ? " + list.isEmpty());

        list.add("111");
        // 在指定位置新增一個set集合
        list.addAll(0,at.putSet("1","2","3"));
        System.out.println(list);

        // 是否包含指定元素
        if(list.contains("111")) {
            list.remove("111");
        }
        System.out.println(list);

        System.out.println(list.indexOf("1"));
        // 注意subList()這個方法是左開右閉區間,Java 中很多都是類似的
        System.out.println(list.subList(0,3));

        // 擴大list的容量
        list.ensureCapacity(10);
        // 去掉list空閒的容量
        list.trimToSize();

        // 獲取某個特定的元素
        System.out.println(list.get(1));

        // 建立一個list的雙向連結串列
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            // 移到list的末端
            System.out.println(listIterator.next());
        }
        System.out.println("--------------------------");
        while (listIterator.hasPrevious()){
            // 移到list的首端
            System.out.println(listIterator.previous());
        }

        // 把list轉換為陣列
        Object[] objects = list.toArray();
        System.out.println("objects = " + objects);

    }
}

相關方法原始碼分析

原始碼的具體分析是根據上面的程式碼示例得出,因為只看原始碼好像並不能看懂什麼,需要根據具體的程式碼一步一步debug 進行跟蹤

add()方法

解釋:新增指定的元素在list的末尾

    /**
     * 新增指定的元素在list的末尾
     */
    // 假設第一次新增的是 "111"
    public boolean add(E e) {
        // size是0,所以size + 1 傳的是1
        ensureCapacityInternal(size + 1); 
        // elementData[0] = 111 , size++ = 1
        elementData[size++] = e;
        return true;
    }
    
    // 此方法用來進行list 擴容
    private void ensureCapacityInternal(int minCapacity) {
        // 此時elementData 並沒有儲存元素,為0
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 則minCapacity 取預設初始容量和minCapacity 的最大值 (取1 和 10的最大值)
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 確保清晰的容量(最小容量與List元素的比較)
        ensureExplicitCapacity(minCapacity);
    }

    // 在list中添加了一個元素,所以會導致結構化的修改,"結構化的修改"見下面解釋
    // 此時minCapacity 為 10
    private void ensureExplicitCapacity(int minCapacity) {
        // 次數 + 1 
        // 這個列表被修改結構的次數(比如新增和刪除元素)會用modCount表示. 結構化修改是指的是能夠
        // 改變列表容量的操作,或者其他方式改變它,導致遍歷的過程會產生錯誤的結果。
        modCount++;

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

    /**
     * 增加容量確保容納足夠的元素
     * 
     * 引數傳過來的是10
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        // oldCapacity = 0
        int oldCapacity = elementData.length;
        // newCapacity = 0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // newCapacity - minCapacity = -10
        if (newCapacity - minCapacity < 0)
            // newCapacity = 10
            newCapacity = minCapacity;
        
        // MAX_ARRAY_SIZE = 陣列分配的最大空間 = 2147483639
        // 一般情況下不會比 MAX_ARRAY_SIZE 還要大
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // 底層還是用的System.arraycopy(), 關於System.arrayCopy() 讀者可以參考我的另一篇部落格
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    

相關常用的基本資料型別包裝類的值: Java基本資料型別包裝類常用的值

add(int index, E element)

解釋:在list中指定位置插入指定的元素,如果當前位置有元素,就移動當前位置的元素

    
    /**
     * 在list中指定位置插入指定的元素,如果當前位置有元素,就移動當前位置的元素
     * 要插入的位置的後面所有元素的位置向前 + 1
     *
     */
    public void add(int index, E element) {
        // 檢查 0 這個位置是否越界
        rangeCheckForAdd(index);

        // 不再贅述,讀者可以自行debug
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 因為從當前位置插入元素,所以當前位置及後面的元素都會向後移動
        // 使用System.arraycopy 進行陣列複製
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 為當前元素賦值
        elementData[index] = element;
        size++;
    }

    /**
     * 為add 和 addall 提供的範圍檢查, 不符合條件,丟擲IndexOutOfBoundsException 異常
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    

Clear()

解釋:移除列表中的所有元素

    /**
     * 移除list列表中所有的元素,列表會變為空列表在呼叫此方法後
     *
     */
    public void clear() {
        // 修改次數 + 1
        modCount++;

        // clear to let GC do its work
        // 把每個變數置空,GC進行回收
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        // 列表的長度變為0
        size = 0;
    }

這個方法的原始碼理解起來還是比較簡單的

addAll(Collection<? extends E> c)

解釋: 把一個Collection集合新增到list末尾

    /**
     * 把一個Collection集合(實現了此介面的類)新增到list的末尾,按著迭代的順序返回。
     * 此操作的行為是如果在此方法呼叫的過程中修改了Collection(實現了此介面的類)的話,
     * 那麼這個操作不會成功
     */
    public boolean addAll(Collection<? extends E> c) {
        // 把Collection 轉換為 Object[] 陣列
        Object[] a = c.toArray();
        // 陣列中有三個元素
        int numNew = a.length;
        // 因為上面的操作呼叫了一次list.clear()方法,所以list.size = 0
        ensureCapacityInternal(size + numNew);  // Increments modCount
        // 一句話解釋: 把a 陣列中0個位置的元素 複製到 elementData陣列中 第size個位置的元素,
        // 複製的長度為 numNew
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    // toArray()方法: 

    /**
     * 返回一個數組,包含了所有的元素(從第一個元素到最後一個元素)
     * 返回的陣列是很"安全的"因為列表沒有引用可以維持(換句話說,這個方法必須分配一個新陣列)
     * 呼叫者因此可以任意修改返回的陣列
     * 這個方法是陣列 和 集合之間的橋樑
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

iterator(), hasNext(), next()

解釋:Iterator方法用於遍歷list中的元素,返回一個Itr 的內部類,hasNext()方法用於判斷list 中是否還有未遍歷的元素,next()方法用於獲取下一個元素

    /**
     * 以適當的順序返回此列表中元素的迭代器
     * 返回的iterator 支援fail-fast 機制
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * Itr 是一個內部類,實現了Iterator介面,可支援快速遍歷
     */
    private class Itr implements Iterator<E> {
        // 下一個元素返回的下標
        int cursor;       // index of next element to return
        // 最後一個元素返回的下標, 如果沒有返回-1
        int lastRet = -1; // index of last element returned; -1 if no such
        // expectedModCount 期望的修改次數,預設是和modCount(修改次數相同,用於iterator判斷fail-fast機制)
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            // 判斷遍歷的過程中是否觸發fail-fast機制
            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() {
            // 如果lastRet < 0,說明 lastRet 沒有被改變,
            // 所以應該是沒有呼叫next()就呼叫了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++]);
            }
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        // 如果修改次數不滿足預期修改次數的話,丟擲異常
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

addAll(int index,Collection<? extends E> c)

解釋:在某個位置新增Collection集合

    /**
     * 在指定的位置下標插入一個Collection集合
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

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

        // 需要移動的元素個數
        int numMoved = size - index;
        if (numMoved > 0)
            // 第一次陣列複製,從elementData中的index位置開始,複製到index + numNew位置上,複製numMoved個元素
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        // 第二次陣列複製,從a 陣列中的第0個位置開始,複製到elementData第index位置上你,複製numNew個元素
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    

contains(Object o)

解釋:判斷list列表是否包含某個元素

    /**
     * 返回true,如果這個列表包含指定的元素
     * 更進一步來說,當且僅當list包含至少一個元素的情況下,返回true
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 返回列表中第一次出現指定元素的下標值,如果不包含指定元素,則返回-1。
     * 更進一步來說,返回最小的索引當(o == null ? get(i) == null : o.equals(get(i)))的時候
     * 或者返回-1 沒有此下標值
     *
     */
    public int indexOf(Object o) {
        // 如果o這個物件等於null,就判斷elementData中是否有空元素,如果有,返回
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            // 如果不為null,返回這個值的儲存位置
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

remove(Object o)

解釋:移除list中的某個元素

    /**
     * 如果存在,則移除list中某個第一次出現的元素。如果這個list不包含指定元素,就不會改變
     *
     */
    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;
    }

    /*
     * 私有的移除方法,並且不返回被移除的元素,這個原始碼比較簡單
     */
    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
    }

indexOf(Object o)

解釋:檢索某個元素的位置

此原始碼和contains(Object o)中呼叫的indexOf 原始碼相同

subList(int fromIndex, int toIndex)

解釋:返回list列表的一個片段

    /**
     * 返回list列表中的一部分檢視(相當於list片段),[fromIndex,toIndex),如果fromIndex 和
     * toIndex 相同的話,表明這個list為空,這個返回的list被返回,所以在list中並沒有結構的改變
     * 這個返回的list片段支援所有的list操作
     */
    public List<E> subList(int fromIndex, int toIndex) {
        // subList 範圍檢查
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }

    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }

    private class SubList extends AbstractList<E> implements RandomAccess {
        
        private final AbstractList<E> parent;
        private final int parentOffset;
        private final int offset;
        int size;

        SubList(AbstractList<E> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            this.offset = offset + fromIndex;
            this.size = toIndex - fromIndex;
            this.modCount = ArrayList.this.modCount;
        }
    }

ensureCapacity(int minCapacity)

解釋:擴大list的容量

    /**
     * 增加ArrayList例項的容量,如果必須的話,確保它能持有最小容量的元素
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

trimToSize()

解釋:去掉list空閒的容量

    /**
     * 去掉ArrayList中的多餘空間
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

sort(Comparator<? super E> c)

sort 方法接收一個自定義比較器進行自定義比較,下面來看具體的原始碼

        @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        // 根據上面程式碼分析,此時modCounnt 已經被修改過三次(添加了三個元素)
        final int expectedModCount = modCount;
        // 陣列外部排序
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }