LinkedList源码简要分析

1.简述LinkedList

• LinkedList 继承自List和Deque，Deque是双端队列，说明LinkedList可以作为双端队列使用。
• LikedList底层是一个双向链表

transient Node<E> first;  链表头节点
transient Node<E> last; 链表尾节点

• LinkedList根据索引index查询时，会根据索引index是否大于总元素个数的一半来决定是从前往后还是从后往前遍历
• remove(Object o） 只会移除链表中第一个复合条件的元素
• 按索引位插入，按索引位查找元素，删除元素都需要去遍历链表

2.新增功能

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

void linkLast(E e) {
    final Node<E> l = last;
		// newNode的prev节点设置为last节点
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode; // 将newNode 节点设置为l的下一个节点，与前面创建节点构成了双向链表

    modCount++; // Linked改变次数
}

3.根据索引获取元素

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

4. 基于索引位新增元素 add(int index, E element)

public void add(int index, E element) {
		// 检查索引是否越界
    checkPositionIndex(index);

    if (index == size)
				// 索引跟size一样时，说明就是往last节点后添加节点，直接走add(E e)一样的方法
        linkLast(element);
    else
				// 中间插入，通过node(index) 先查找到索引所在的节点
        linkBefore(element, node(index));
}

// 1.获取索引位的前置节点pred ，pred.next = newNode
// 2.当前节点指向索引位  newNode.next = succ
// 链表的插入完成
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
		// 获取索引位当前节点的prev节点
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
		索引位节点的的前置节点指向新插入的节点newNode
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
				//然后将pred节点的next节点指向新插入的节点newNode
        pred.next = newNode;
    size++;
    modCount++;
}

5.删除元素remove(Object o)

public boolean remove(Object o) {
    if (o == null) {
				// 针对元素为null的特殊处理
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
				// 遍历链表，找到第一个与o相等的元素，进行删除
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
								// 删除元素
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

E unlink(Node<E> x) {
    // assert x != null;
		要被移除的元素值
    final E element = x.item;
		// 要被移除的元素的下一个节点next
    final Node<E> next = x.next;
		//要被移除元素的前置节点prev
    final Node<E> prev = x.prev;
		
		//  prev和next进行连接   prev.next = next
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

		// prev和next进行连接    next.prev = prev
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
		// 快速释放
    x.item = null;
    size--;
    modCount++;
    return element;
}