ArrayList與LinkedList源碼分析-從源碼角度分析數組與鏈表的區別

ArrayList與LinkedList都是線性表，是可以儲存具有相同特性的數據元素的有限序列。但它們內部實現是截然不同的，分別代表了數組和鏈表的兩種實現，這也注定了它們算法的時間復雜度與空間復雜度是不一樣的，需要擇優使用在不同的場景。接下來將源碼（JDK1.8）細節去分析它們的差異。

ArrayList源碼分析

  • 無參構造函數
transient Object[] elementData;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

elementData是一個Object數組，使用transient關鍵字修飾,transient關鍵字與Serializable接口配合使用，使用transient關鍵字修飾的變量不會被序列化。

  • int參數構造
private static final Object[] 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);
        }
    }

當傳入的initialCapacity大于0時，初始化一個長度為initialCapacity的Object數組

  • Collection參數構造
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

public interface Collection<E> extends Iterable<E> {
    Object[] toArray();
    <T> T[] toArray(T[] a);
}

Collection是一個接口，List、Set、Queue接口繼承自Collection接口，所以這里的參數c可以是List、Set、Queue的實現類。toArray()方法有兩個，分別返回Object數組和泛型數組。如果toArray()是泛型數組，則拷貝一份到Object數組中并返回。

  • add(E e)方法
    public boolean add(E e) {
        ensureCapacityInternal(size + 1); 
        elementData[size++] = e;
        return true;
    }

    private static final int DEFAULT_CAPACITY = 10;
    private void ensureCapacityInternal(int minCapacity) {
        //如果實際存儲數組 是空數組，則最小需要容量就是默認容量
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//結構改變次數

        //如果數組（elementData)的長度小于最小需要的容量（minCapacity）就擴容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        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);
    }

ArrayList在沒指定initialCapacity時就是相當于會使用延遲分配對象數組空間，當第一次插入元素時才分配10（默認）個對象空間。假如有20個數據需要添加，那么會分別在第一次的時候，將ArrayList的容量變為10；之后擴容增加數組的size>>1的長度,也就是會按照 1.5倍增長。也就是當添加第11個數據的時候，Arraylist繼續擴容變為10*1.5=15；當添加第16個數據時，繼續擴容變為15 * 1.5 =22個。

  • add(int index, E element)
    public void add(int index, E element) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        ensureCapacityInternal(size + 1);  // 擴容，和add(E e)一樣
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

System.arraycopy()方法是一個原生的靜態方法，用于從源數組拷貝元素到目標數組中
System.arraycopy() 方法如下:

public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,
int length);

src: 源數組 .
srcPos: 源數組中開始拷貝的索引值
dest: 目標數組
destPos: 拷貝到目標數組開始的索引值
length: 拷貝元素的個數
add(int index, E element)就是將index后面的數組copy了一份，并將索引值加1，然后將數組index索引賦值。

  • E get(int index)
    public E get(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        return (E) elementData[index];
    }
  • E set(int index, E element)
    public E set(int index, E element) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        E oldValue = (E) elementData[index];
        elementData[index] = element;
        return oldValue;
    }
  • E remove(int index)
    public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) elementData[index];

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null;

        return oldValue;
    }

numMoved表示要左移的元素，是否是大于0，大于0則將index后的元素左移一個位置，并將最后一個索引的最后一個元素置空。如果等于0，說明是index最后一個元素的索引，不需要左移，直接將最后一個索引置空。

  • boolean 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;
    }

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

判斷要移除的object是否為空，為空則移除第一個為null的元素。不為空時則用equals進行比較，如果元素沒有重寫equals方法，就比較內存地址，有重寫就比較定義的equals規則，移除第一個內存地址相同或equals規則相同的元素。

ArrayList總結

  • 1.底層數組實現，使用默認構造方法初始化出來的容量是10
  • 2.擴容的長度是在原長度基礎上加上>>1
  • 3.底層是數組，get獲取元素性能很好
  • 4.線程不安全，所有的方法均不是同步方法也沒有加鎖，因此多線程下慎用
  • 5.添加刪除和插入需要復制數組 性能較低

LinkedList源碼分析

  • 無參構造
    public LinkedList() {
    }
  • Collection參數構造
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

        //將c中的元素都添加到鏈表中
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);//添加到鏈表尾部
    }

    //在序號為index處，添加c中所有的元素到當前鏈表中（后向添加）
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);//檢查索引是否合法

        Object[] a = c.toArray();//將集合轉換為數組
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {//構造方法會走這里，如果index為元素個數，即index個結點為尾結點
            succ = null;
            pred = last;//前指向指向尾結點，構造方法last這里是null
        } else {
            succ = node(index); 
            pred = succ.prev;   
        }

        //for循環結束后，數組a里面的元素都添加到當前鏈表里面，后向添加
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //新生成一個結點，結點的前向指針指向pred,后向指針為null
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                //如果pred為null，則succ為當前頭結點,構造方法會走這里
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;//pred移動到新結點
        }

        if (succ == null) {
            last = pred;//succ為null，這表示index為尾結點之后，構造方法會走這里
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;//元素個數+num
        modCount++;//修改次數+1
        return true;
    }

Collection參數的構造方法將Collection轉成數組，并循環遍歷數組長度創建Node節點，并將雙向鏈表前后指針賦值。

  • add(E e) 、offer(E e)
   public boolean offer(E e) {
        return add(e);
    }

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

add(E e)調用linkLast(E e)方法把元素添加到尾部，添加到尾部時創建新的節點，prev指針指向最后一個節點，next指針指向null。當最后一個節點為空，說明當前linkedlist元素為空，把新節點作為第一個節點。否則將原來的最后節點的next指針指向新節點。

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

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    Node<E> node(int index) {
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

當add(int index, E element)傳入索引==size,調用linkLast(element)添加到后面，在add(E e)中已經分析。不等于size,調用linkBefore(element, node(index))添加到中間或最前面，node(index)方法獲取原Node節點，因為采用雙向鏈表的設計，獲取原Node節點只需遍歷一半，將時間復雜度O(n)變成了O(n/2)，這也是雙向鏈表比單向鏈表的優點。繼續回到linkBefore(E e, Node<E> succ)分析，首先獲取原索引Node節點的prev指針，創建新節點，新節點的prev指向原Node的prev，next指針指向原Node。當原節點不為空，將原Node的next指針指向新Node，如果原節點為空，首節點賦值為新Node。

  • E remove(int index)
    public E remove(int index) {
        checkElementIndex(index);//檢查索引是否合法
        return unlink(node(index));
    }

    E unlink(Node<E> x) {
        final E element = x.item;
        final Node<E> next = x.next;//后一個節點
        final Node<E> prev = x.prev;//前一個節點

        if (prev == null) {//移除的是第一個節點
            first = next;
        } else {
            prev.next = next;//前一個節點的next指針指向后一個節點
            x.prev = null;//移除原節點的prev指針指向
        }

        if (next == null) {//如果移除的是最后一個節點
            last = prev;//將最后的last賦值為前一個節點
        } else {
            next.prev = prev;//將后一個節點的prev指針指向前一個節點
            x.next = null;//移除原節點的next指針指向
        }

        x.item = null;//置空原節點
        size--;
        modCount++;
        return element;
    }

E remove(int index)調用E unlink(Node<E> x)方法，獲取索引Node的item，和前后節點，將前后節點的prev和next指針對應指向，并斷開了原節點prev和next指向，并置空原索引節點，返回原節點item。

  • boolean remove(Object o)
public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

boolean remove(Object o)比E remove(int index)多了一步，需要先遍歷獲取索引，然后再調用unlink(Node<E> x)方法，，其他和E remove(int index)一樣。

LinkedList總結

  • 1.LinkedList的實現是基于雙向鏈表的，且頭結點中不存放數據。
  • 2.無參構造方法直接建立一個僅包含head節點的空鏈表；包含Collection的構造方法，先調用無參構造方法建立一個空鏈表，而后將Collection中的數據加入到鏈表的尾部后面 。
  • 3.在查找和刪除某元素時，源碼中都劃分為該元素為null和不為null兩種情況來處理，LinkedList中允許元素為null。
  • 4.LinkedList是基于鏈表實現的，不存在容量不足的問題，所以沒有擴容的方法。
  • 5.Node node(int index)方法。該方法返回雙向鏈表中指定位置處的節點，而鏈表中是沒有下標索引的，要指定位置出的元素，就要遍歷該鏈表，從源碼的實現中，我們看到這里有一個加速動作。源碼中先將index與長度size的一半比較，如果index<(size<<1)，就只從位置0往后遍歷到位置index處，而如果index>(size<<1)，就只從位置size往前遍歷到位置index處。這樣可以減少一部分不必要的遍歷，從而提高一定的效率。
  • 6.LinkedList是基于鏈表實現的，插入刪除效率高，查找效率低。
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。