資料結構:用例項分析ArrayList與LinkedList的讀寫效能

智慧zhuhuix發表於2020-06-04

背景

ArrayList與LinkedList是Java程式設計中經常會用到的兩種基本資料結構，在書本上一般會說明以下兩個特點：

對於需要快速隨機訪問元素，應該使用ArrayList。

對於需要快速插入，刪除元素，應該使用LinkedList。

該文通過實際的例子分析這兩種資料的讀寫效能。

ArrayList

ArrayList是實現了基於動態陣列的資料結構：

private static final int DEFAULT_CAPACITY = 10;
...
transient Object[] 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);
        }
    }

LinkedList

LinkedList是基於連結串列的資料結構。

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
...    
transient Node<E> first;
transient Node<E> last;
...
private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

例項分析

通過對兩個資料結構分別增加、插入、遍歷進行讀寫效能分析

1、增加資料

public class ArrayListAndLinkList {
    public final static int COUNT=100000;
    public static void main(String[] args) {

        // ArrayList插入
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        Long start = System.currentTimeMillis();
        System.out.println("ArrayList插入開始時間：" + sdf.format(start));

        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(i);
        }

        Long end = System.currentTimeMillis();
        System.out.println("ArrayList插入結束時間：" + sdf.format(end));
        System.out.println("ArrayList插入" + (end - start) + "毫秒");


        // LinkedList插入
        start = System.currentTimeMillis();
        System.out.println("LinkedList插入開始時間：" + sdf.format(start));
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < COUNT; i++) {
            linkedList.add(i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList插入結束時間：" + sdf.format(end));
        System.out.println("LinkedList插入結束時間" + (end - start) + "毫秒");
     }
}

輸出如下：
兩者寫入的效能相差不大！
在這裡插入圖片描述

2、插入資料

在原有增加的資料上，在index:100的位置上再插入10萬條資料。

public class ArrayListAndLinkList {
    public final static int COUNT=100000;
    public static void main(String[] args) {

        // ArrayList插入
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        Long start = System.currentTimeMillis();
        System.out.println("ArrayList插入開始時間：" + sdf.format(start));

        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(i);
        }
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(100,i);
        }

        Long end = System.currentTimeMillis();
        System.out.println("ArrayList插入結束時間：" + sdf.format(end));
        System.out.println("ArrayList插入" + (end - start) + "毫秒");


        // LinkedList插入
        start = System.currentTimeMillis();
        System.out.println("LinkedList插入開始時間：" + sdf.format(start));
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < COUNT; i++) {
            linkedList.add(i);
        }
        for (int i = 0; i < COUNT; i++) {
            linkedList.add(100,i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList插入結束時間：" + sdf.format(end));
        System.out.println("LinkedList插入結束時間" + (end - start) + "毫秒");
     }
}

輸出如下：
ArrayList的效能明顯比LinkedList的效能差了很多。
在這裡插入圖片描述
看下原因：
ArrayList的插入原始碼：

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

ArrayList的插入原理：在index位置上插入後，在index後續的資料上需要做逐一複製。
在這裡插入圖片描述
LinkedList的插入原始碼：

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

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
 }
 ...
  void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        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++;
    }

LinkedList的插入原理：在原來相互連結的兩個節點（Node）斷開，把新的結點插入到這兩個節點中間，根本不存在複製這個過程。
在這裡插入圖片描述

3、遍歷資料

在增加和插入的基礎上，利用get方法進行遍歷。

public class ArrayListAndLinkList {
    public final static int COUNT=100000;
    public static void main(String[] args) {

        // ArrayList插入
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        Long start = System.currentTimeMillis();
        System.out.println("ArrayList插入開始時間：" + sdf.format(start));

        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(i);
        }
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(100,i);
        }

        Long end = System.currentTimeMillis();
        System.out.println("ArrayList插入結束時間：" + sdf.format(end));
        System.out.println("ArrayList插入" + (end - start) + "毫秒");


        // LinkedList插入
        start = System.currentTimeMillis();
        System.out.println("LinkedList插入開始時間：" + sdf.format(start));
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < COUNT; i++) {
            linkedList.add(i);
        }
        for (int i = 0; i < COUNT; i++) {
            linkedList.add(100,i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList插入結束時間：" + sdf.format(end));
        System.out.println("LinkedList插入結束時間" + (end - start) + "毫秒");

        // ArrayList遍歷
        start = System.currentTimeMillis();
        System.out.println("ArrayList遍歷開始時間：" + sdf.format(start));
        for (int i = 0; i < 2*COUNT; i++) {
            arrayList.get(i);
        }
        end = System.currentTimeMillis();
        System.out.println("ArrayList遍歷開始時間：" + sdf.format(end));
        System.out.println("ArrayList遍歷開始時間" + (end - start) + "毫秒");

        // LinkedList遍歷
        start = System.currentTimeMillis();
        System.out.println("LinkedList遍歷開始時間：" + sdf.format(start));
        for (int i = 0; i < 2*COUNT; i++) {
            linkedList.get(i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList遍歷開始時間：" + sdf.format(end));
        System.out.println("LinkedList遍歷開始時間" + (end - start) + "毫秒");

    }
}

輸出如下：
在這裡插入圖片描述
兩者的差異巨大：
我們看一下LInkedList的get方法：從頭遍歷或從尾部遍歷結點

public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
 ...
 Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }

3.1、LinkedList遍歷改進

我們採用迭代器對LinkedList的遍歷進行改進：

		...
		// LinkedList遍歷
        start = System.currentTimeMillis();
        System.out.println("LinkedList遍歷開始時間：" + sdf.format(start));
        Iterator<Integer> iterator = linkedList.iterator();
        while(iterator.hasNext()){
            iterator.next();
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList遍歷開始時間：" + sdf.format(end));
        System.out.println("LinkedList遍歷開始時間" + (end - start) + "毫秒");

再看下結果：
兩者的遍歷效能接近。
在這裡插入圖片描述

總結

List使用首選ArrayList。對於個別插入刪除非常多的可以使用LinkedList。
LinkedList，遍歷建議使用Iterator迭代器，尤其是資料量較大時LinkedList避免使用get遍歷。

Java資料結構之LinkedList、ArrayList的效率分析
2017-03-06
Java資料結構
ArrayList 資料結構分析
2018-05-18
資料結構
LinkedList 資料結構分析
2018-05-20
資料結構
ArrayList與linkedlist插入效率分析
2017-05-23
Java ArrayList 與 LinkedList
2021-10-30
Java
資料結構與集合之（1）ArrayList 與 Arrays
2020-11-05
資料結構
List集合總結，對比分析ArrayList，Vector，LinkedList
2019-06-30
資料結構--LinkedList的實現
2021-01-05
資料結構
資料結構分析及其實現(Stack、Queue、Tree、LinkedList)
2019-03-01
資料結構
Java 的 ArrayList 的底層資料結構
2018-08-08
Java資料結構
例項分析JAVA CLASS的檔案結構
2019-02-21
Java
ARRAYLIST VECTOR LINKEDLIST 區別與用法
2008-09-04
ArrayList和LinkedList的幾種迴圈遍歷方式及效能對比分析
2014-06-30
【學習】體系結構-001-例項與資料庫
2018-04-19
資料庫
說出 ArrayList,Vector, LinkedList 的儲存效能和特性？
2015-06-09
Java ArrayList 與 LinkedList 的靈活選擇
2024-03-08
Java
【資料結構】ArrayList原理及實現
2018-08-08
資料結構
Java-ArrayList & LinkedList的原始碼對比分析
2020-11-16
Java原始碼
資料結構與演算法分析讀書筆記(樹)
2017-04-16
資料結構演算法筆記
Cassandra 分散式資料庫詳解，第 2 部分：資料結構與資料讀寫
2012-08-01
分散式資料庫資料結構
每週一練之資料結構與演算法（LinkedList）
2019-04-22
資料結構演算法
資料庫的備份與恢復分析及例項
2014-02-25
資料庫
資料結構之LinkedList | 讓我們一塊來學習資料結構
2021-04-29
資料結構
Java Class檔案結構例項分析（下）
2018-12-18
Java
Java Class檔案結構例項分析（上）
2018-10-14
Java
【前端構建】WebPack例項與前端效能優化
2016-03-03
前端Web優化
ArrayList和LinkedList的區別？
2019-03-03
ArrayList和LinkedList的區別
2019-01-18
ArrayList和LinkedList的比較
2024-07-05
ArrayList底層結構和原始碼分析
2024-07-05
原始碼
Oracle例項和Oracle資料庫(Oracle體系結構)
2013-12-05
Oracle資料庫
資料結構：初識（資料結構、演算法與演算法分析）
2020-07-21
資料結構演算法
LinkedList和ArrayList的區別、Vector和ArrayList的區別
2019-12-26
ArrayList & LinkedList原始碼解析
2021-10-10
原始碼
資料結構與演算法分析——棧
2019-12-05
資料結構演算法
資料結構與演算法分析——連結串列
2019-12-03
資料結構演算法
資料結構與演算法分析讀書筆記(連結串列棧佇列)
2017-04-11
資料結構演算法筆記佇列
ArrayList和LinkedList如何實現的？
2020-08-14