linkedList源码解析

标题linkedList源码解析

概述：
Linkedlist是List的实现类，它是一个集合，可以通过索引随机访问集合中的元素，还实现了queue接口，可以当成队列使用，虽然Lindedlist实现了list接口，但是它的实现与arraylist完全不同，arraylist通过动态的Object[]实现，Linkedlist通过链表的方式实现，因此它的查找方式是比arraylist差的，删除和插入是比较快的
linkedList结构图如下图所示

First：链表头节点
Last：链表尾节点
Pre：上一个节点
Next：下一个节点

继承关系：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

基础属性

// 链表长度
transient int size = 0;
// 头节点
transient Node<E> first
// 尾节点
transient Node<E> last;
// 修改次数
protected transient int modCount = 0;

链表节点类

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

**构造方法**

 空构造器 创建对象
public LinkedList() {
}

有参构造器,先初始化lindedlist 在将传入Collection集合添加到链表中 
public LinkedList(Collection<? extends E> c) {
// 创建linkedlist对象
    this();
// 将集合添加到链表中
    addAll(c);
}

/**
 * 获取第一个元素
 */
public E getFirst() {
// 获取头节点
    final Node<E> f = first;
// 若为空则抛NoSuchElementException
    if (f == null)
        throw new NoSuchElementException();
// 返回当前头节点的值
    return f.item;
}

/**
 * 根据下标获取元素
 */
public E get(int index) {
// 基础校验
    checkElementIndex(index);
// 获取节点数据((node方法详解见下方)
    return node(index).item;
}

/**
 * 获取尾节点(原理与getFirst()差不多，这里就不多做解释了)
 */
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

/**
 * 新增
 */
public boolean add(E e) {
// 在last节点后添加元素
    linkLast(e);
    return true;
}

/**
 * 在last节点后添加元素
 */
void linkLast(E e) {
	// 获取尾节点值（临时变量）
    final Node<E> l = last;
	// 创建新节点
	// 因是最后一个元素，所以next节点为空
    final Node<E> newNode = new Node<>(l, e, null);
	// 更新最后一个节点引用为新节点
    last = newNode;
	// 若尾节点为空，则表示整个linkedlist为空
    if (l == null)
		// 更新头节点引用为新节点
        first = newNode;
    else
       //否则之前的尾节点已为现在的倒数第二个节点，所以，l的next节点为newNode
 	l.next = newNode;
    size++; 刷新总数
    modCount++; 刷新修改次数
    }

图解：

/**
 *  指定位置插入
 */
public void add(int index, E element) {
    checkPositionIndex(index);

	// 若下标==链表长度，则直接在尾节点后面插入
    if (index == size)
        linkLast(element);
    else
		// 其他情况则在节点前插入
        linkBefore(element, node(index));
}

/**
 *  基础校验
 */
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

/**
 *  获取索引处链表节点（避免遍历整个链表）
 */
Node<E> node(int index) {
   // 如果下标小于size一半，则从头节点开始遍历查找
    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;
    }
}

/**
 *  链表添加到指定节点之前
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
	// succ前一个节点
    final Node<E> pred = succ.prev;
	// 创建新节点，前节点则是pre，下一个节点则是succ
    final Node<E> newNode = new Node<>(pred, e, succ);
	// succ前节点设置为新节点（因为新节点在succ前一个节点）
    succ.prev = newNode;
	// 若succ前一个节点为空节点，则说明succ为首节点
    if (pred == null)
		// 则头节点为新节点
        first = newNode;
    else
		// succ最开始的前节点的next节点则指向新节点
        pred.next = newNode;
    size++; 刷新总数
    modCount++; 刷新修改次数
}

图解：

/**
 *   将指定集合添加到链表中
 */
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
	// 校验 与前面一样
    checkPositionIndex(index);
    // 将传入集合转为Object数组
    Object[] a = c.toArray();
	// 获取数组长度
    int numNew = a.length;
    if (numNew == 0)
        return false;
    // 声明前驱节点和后继节点
    Node<E> pred, succ;
	// 若下标==size，则表明从尾节点插入
    if (index == size) {
        succ = null; // 设置后继节点为null
        pred = last; 设置前驱节点为尾节点
    } else {
		// 后继节点为node(index)
        succ = node(index);
		// 前驱节点为succ.prev
        pred = succ.prev;
    }

	// 遍历数组
    for (Object o : a) {
        // a中元素强转为E元素
        @SuppressWarnings("unchecked") E e = (E) o;
        // 新节点，添加于尾部
        Node<E> newNode = new Node<>(pred, e, null);
	    // pre==null 则创建一个头节点
        if (pred == null)
            first = newNode;
        else
			// 其他情况，则在前驱节点的下一个节点插入新节点
            pred.next = newNode;
			// 为了下次循环做准备 则将前驱节点设置为newNode
        pred = newNode;
    }
    
	// 若后继节点为空，则说明是尾元素
    if (succ == null) {
		// 因为前面循环把pred设置为newNode，则新节点为尾元素
        last = pred;
    } else {
    	// 新节点的后驱节点为最开始下标的节点(因为这种情况节点是往前插入的)
		pred.next = succ;
		
		// 前驱节点为当前节点
        succ.prev = pred;
    }
    // 更新总数
    size += numNew;
    //刷新修改次数
    modCount++;
    return true;
}

/**
 *   删除指定下标节点
 */
public E remove(int index) {
// 与前面一致校验
    checkElementIndex(index);
// 删除指定下标节点元素
    return unlink(node(index));
}

/**
 *   删除元素
 */
E unlink(Node<E> x) {
	// 存储节点的值
    final E element = x.item;
	// 存储下节点
    final Node<E> next = x.next;
	// 存储上节点
    final Node<E> prev = x.prev;

	// 前驱节点为空，则说明是首节点
    if (prev == null) {
        first = next;
    } else {
	// 其他情况，则前驱节的next指向后驱节点
        prev.next = next;
	// 当期节点的前驱节点置为空
        x.prev = null;
    }

	// 若传入节点未有下一个节点，则说明是尾节点，直接将尾节点赋值给前驱节点即可
    if (next == null) {
        last = prev;
    } else {
		// 其他情况，则把后驱节点前prev设置为前驱节点
        next.prev = prev;
		// 后驱节点设置为null
        x.next = null;
    }
    // 将当前节点值设置为null
    x.item = null;
	// 更新总数
    size--;
	// 刷新修改次数
    modCount++;
	// 返回删除的元素值
    return element;
}

图解：