資料結構:用例項分析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遍歷。

LinkedList 資料結構分析
2018-05-20
資料結構
ArrayList 資料結構分析
2018-05-18
資料結構
Java ArrayList 與 LinkedList
2021-10-30
Java
資料結構--LinkedList的實現
2021-01-05
資料結構
List集合總結，對比分析ArrayList，Vector，LinkedList
2019-06-30
資料結構與集合之（1）ArrayList 與 Arrays
2020-11-05
資料結構
資料結構分析及其實現(Stack、Queue、Tree、LinkedList)
2019-03-01
資料結構
【學習】體系結構-001-例項與資料庫
2018-04-19
資料庫
例項分析JAVA CLASS的檔案結構
2019-02-21
Java
Java 的 ArrayList 的底層資料結構
2018-08-08
Java資料結構
Java-ArrayList & LinkedList的原始碼對比分析
2020-11-16
Java原始碼
Java ArrayList 與 LinkedList 的靈活選擇
2024-03-08
Java
每週一練之資料結構與演算法（LinkedList）
2019-04-22
資料結構演算法
Java Class檔案結構例項分析（下）
2018-12-18
Java
Java Class檔案結構例項分析（上）
2018-10-14
Java
【資料結構】ArrayList原理及實現
2018-08-08
資料結構
資料結構之LinkedList | 讓我們一塊來學習資料結構
2021-04-29
資料結構
ArrayList和LinkedList的區別？
2019-03-03
ArrayList和LinkedList的區別
2019-01-18
ArrayList和LinkedList的比較
2024-07-05
ajax讀取資料庫資料程式碼例項
2018-07-31
資料庫
frida 建立一個ArrayList例項
2024-11-02
3、List集合——ArrayList、LinkedList
2020-11-13
ArrayList & LinkedList原始碼解析
2021-10-10
原始碼
ArrayList和LinkedList如何實現的？
2020-08-14
LinkedList和ArrayList的區別、Vector和ArrayList的區別
2019-12-26
ArrayList底層結構和原始碼分析
2024-07-05
原始碼
oracle資料庫與oracle例項
2024-06-01
Oracle資料庫
探索JAVA系列(二)LinkedList插入資料真的比ArrayList快嗎？
2019-03-05
Java
【java】【集合】LinkedList的特有功能，用LinkList模擬棧和佇列資料結構
2018-04-24
Java佇列資料結構
資料結構：初識（資料結構、演算法與演算法分析）
2020-07-21
資料結構演算法
資料結構與演算法分析——棧
2019-12-05
資料結構演算法
專家解讀：利用Angular專案與資料庫融合例項
2020-06-23
Angular資料庫
資料結構與演算法分析——連結串列
2019-12-03
資料結構演算法
資料庫例項效能調優利器：Performance Insights
2019-10-08
資料庫ORM
Redis的資料結構與應用場景
2021-02-18
Redis資料結構
C# 8: 可變結構體中的只讀例項成員
2020-11-11
C#結構體
java中的List介面(ArrayList、Vector、LinkedList)
2022-03-11
Java