LinkedList实现原理及源码浅析

LinkedList实现原理

LinkedList是使用一个双向链表实现的。

每个节点的数据结构如下

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
    
	Node(Node<E> prev, E element, Node<E> next) { // 创建一个Node
            this.item = element;
            this.next = next;	// 设置node在双向链表中的下一个node代表的对象
            this.prev = prev;	// 设置node在双向链表中的前一个node代表的对象
	}
    
}

组成的双向链表如下同所示

浅析LinkedList源码

查找

public E get(int index) // 获得目标位置上的元素

从源码可以看到是先用node方法拿到目标节点，再返回目标节点的item属性

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

node方法实现如下，就是遍历双向链表找到目标元素

Node<E> node(int index) {
    // assert isElementIndex(index);
	
    // 如果目标位置小于双向链表的长度的一半，则通过next从前往后遍历，否则通过prev从后往前遍历
    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;
    }
}

public int indexOf(Object o) // 查找目标元素第一次出现的位置

源码如下。比较简单，就只是通过遍历双向链表找到对应元素所在位置

public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

添加

public boolean add(E e) // 直接添加元素

源码如下

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

linkLast的实现如下, 这个方法的作用就是把元素插入到LinkedList的双向链表的最后

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null); // 为该元素创建一个新的节点，新的节点的前一个节点是双向链表的最后一个节点， 新的节点的后一个为null
    last = newNode;	// 将最后一个节点设置为新的节点
    if (l == null)  // 双向链表的最后一个节点为null，说明双向链表是空的，所以要把双向链表的抵押给节点设置成新节点
        first = newNode;
    else			// 此时新节点的前一个节点，也就是之前的最后一个节点的next还是null， 需要把这个节点的next设为新的节点，这样才完成了新节点的插入
        l.next = newNode;	
    size++;
    modCount++;
}

public void add(int index, E element) // 将元素插入到指定位置

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

    if (index == size)	// 当要插入的位置是双向链表的最后一个元素之后时
        linkLast(element);
    else				// 当要插入的位置在双向链表中时，先找到该位置上的节点，然后把新的元素插入到这个节点之前
        linkBefore(element, node(index));
}

inkBefore的实现如下。

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;	// 把之前在目标位置上的节点的prev设置为新节点
    if (pred == null)		// 如果插入的是头节点，则把first复制为新节点
        first = newNode;
    else					// 如果插入的不是头节点，把新节点的前一个节点的next设置为新节点
        pred.next = newNode;
    size++;
    modCount++;
}

例如add(1, 9)的流程如下

初始状态:

final Node newNode = new Node<>(pred, e, succ); 插入新节点之后如下图。此时item(1)的next还是item(2)， item(2)的prev还是item(1)

succ.prev = newNode; 把item(2)的prev设置为新的节点item(9)

pred.next = newNode; 把item(1)的next设置为新的节点item(9)。插入新节点完成

删除

public E remove(int index) // 删除指定位置上的元素

源码如下，可以看到是先调用node方法获得目标位置上的节点，然后再用unlink方法删除

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

unlink方法如下

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {	   // 如果目标节点的prev为null则说明目标节点是头节点，需要把first赋值为目标节点的下一个节点
        first = next;
    } else {
        prev.next = next;  // 如果目标节点不是头节点，先把目标节点前一个节点的next设置目标节点的后一个节点
        x.prev = null;	   // 先把目标节点的prev设置为null
    }

    if (next == null) {    // 如果目标节点的next为null则说明目标节点是尾节点，先把last设置为之前目标节点的前一个节点
        last = prev;
    } else {
        next.prev = prev;  // 如果目标节点不是尾节点，则把目标节点的下一个节点的prev设置为之前目标节点的前一个节点
        x.next = null;	   // 把目标节点的next为null
    }

    x.item = null;		   // 清空目标节点的item属性，删除节点完成
    size--;
    modCount++;
    return element;
}

例如remove(1)的流程如下

初始状态:

找到目标节点(item(9))

先把目标节点(item(9))前一个节点的next设置目标节点的后一个节点，并目标节点的prev设置为null

则把目标节点(item(9))的下一个节点的prev设置为之前目标节点的前一个节点 ； 并把目标节点的next设置为null, 此时目标节点已经脱离了双向链表

清空目标节点的item属性

public boolean remove(Object o) // 删除目标元素第一次出现的节点

源码如下，可以看出是先找到目标节点，再用unlink方法删除该节点

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

修改

源码如下，可以看大是先找到目标节点，然后修改目标节点的item属性

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}