Java 集合類——Collections（2）

ahiru?發表於2019-03-05
Java

LinkedList

LinkedList的定義：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{...}複製程式碼

  • LinkedList<E>：說明它支援泛型
  • extends AbstractSequentialList<E>：說明LinkedList不支援隨機訪問，只支援按次序訪問
  • 實現了List<E>介面：說明它支援集合的一般操作
  • 實現了Deque<E>介面：說明它可用作佇列和雙向佇列
  • 實現了Cloneable、Serializable：可呼叫clone()方法和可序列化。

transient int size = 0;

/**
 * Pointer to first node.
 * Invariant: (first == null && last == null) || 
 *            (first.prev == null && first.item != null)
 */
transient Node<E> first;

/**
 * Pointer to last node.
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
transient Node<E> last;

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

複製程式碼

Node是雙向連結串列節點所對應的資料結構，包括的屬性是：當前節點的值，上一個節點，下一個節點。

構造方法

public LinkedList() {
}

//接收一個Collection引數c，呼叫第一個構造方法，並把c中所有元素新增到連結串列中
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}複製程式碼

常用方法

  • removeFirst()：刪除表頭元素
  • removeLast()：刪除表尾元素
  • addFirst(E e)：在表頭插入指定元素
  • addLast(E e)：在表尾插入指定元素
  • contains(Object o)：判斷連結串列是否包含指定物件
  • add(E e)：在表尾插入指定元素
  • remove(Object o)：正向遍歷連結串列，刪除第一個值為指定物件的節點
  • addAll(Collection<? extends E> c)：在表尾插入指定集合
  • clear()：清除連結串列中的所有元素

LinkedList的遍歷方式

LinkList遍歷不用for迴圈，因為用迭代器iterator遍歷比for快。

for迴圈遍歷：

for(int i=0; i<list.size(); i++) {
    list.get(i);
}複製程式碼

//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;
    }
}複製程式碼

迭代器遍歷：

List<Integer> list = new LinkedList<>();
Iterator<Integer> iterator = list.listIterator();
while (iterator.hasNext()) {
    Integer i =  iterator.next();
}複製程式碼

//next方法
public E next() {
    checkForComodification();
    if (!hasNext())
        throw new NoSuchElementException();
    lastReturned = next;
    next = next.next;
    nextIndex++;
    return lastReturned.item;
}複製程式碼

從原始碼可以看出，LinkedList如果用for迴圈遍歷，get方法裡面會再次使用迴圈遍歷連結串列，時間複雜度是O(n²)；如果有迭代器遍歷，因為next的存在，得到當前項不需要時間，所以只需要使用一次迴圈，時間複雜度是O(n)。

ArrayList和LinkedList的區別

  • ArrayList是基於動態陣列的資料結構，LinkedList是基於連結串列(雙向連結串列)的資料結構
  • 對於隨機訪問，ArrayList要比LinkedList方便，因為LinkedList是移動指標
  • 關於增加和刪除操作，LinkedList比較方便，ArrayList要慢慢移動元素位置(索引)


參考資料：

Java8原始碼-LinkedList

為什麼使用迭代器iterator遍歷Linkedlist要比普通for快


相關文章