LinkedList集合源码分析

---

前言

链表结构大家应该都清楚，LinkedList就是基于双向链表实现的，前面文章对ArrayList进行了简单的分析，ArrayList是基于数组实现的；本文将对LinkedList进行简单的分析，只要了解链表结构源码看起来非常简单，只是节点之间的绑定解绑操作。

一、数据和链表

双向链表有三个重要的属性：node(数据节点)、pred(上个一个节点)和next(下一个节点)，它是通过节点与节点之间的关联关系链接在一起的，这样做的好处就是增加、删除和遍历比较快，但是其随机查找比数组要慢，正常数组查找某个元素是通过二分查找来计算的，查询效率较快；而链表只能从头遍历到尾部去查找对应的元素。

二、LinkedList

LinkedList是基于双向链表实现的，其内部定义了一个Node类，表示链表的节点。

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

核心属性

LinkedList内部有个Node类，是链表中的节点，这个应该不用说了，基本上了解基本数据结构的都清楚。
LinkedList的核心属性：

• size： 同样记录了LinkedList内部元素的长度。
• first： 第一个元素。
• last： 最后一个元素。

核心方法

构造方法

LinkedList的构造方法就没有指定大小的了，因为其实现是链表不用指定大小。
无参构造就不说了，啥也没有，看一下传递Collection的构造方法。

public LinkedList(Collection<? extends E> c) {
     this();
     addAll(c);
 }
/**
* 核心方法是addAll，将其他类型的Collection中的内容全部转化为链表形式
*/
public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);
	//将集合转化为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
	//查找对应的节点
    Node<E> pred, succ;
    if (index == size) { //刚开始size和index是一样的都是0
        succ = null;
        pred = last;
    } else {  //初始的时候不走这里，链表里面有数据了才走这里
        succ = node(index); //查找对应index位置的节点
        pred = succ.prev;
    }
	//进行循环遍历
    for (Object o : a) {
        @SuppressWarnings("unchecked") 
        E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null) //初次使用pred为空，头结点为创建的节点
            first = newNode;
        else	//设置节点的之间的链接指向
            pred.next = newNode;
        pred = newNode; //再次对中间值赋值
    }
    //赋值最后节点为遍历完成的最后一个节点
    if (succ == null) {
        last = pred;
    } else { //将两个链表之间的链接建立起来
        pred.next = succ; 
        succ.prev = pred;
    }
    size += numNew; //size设置为两个链表的共同长度
    modCount++;
    return true;
}
/**
* 节点查找
*/
Node<E> node(int index) {
	//如果传入的index小于当前链表的长度/2,则从左往右查找
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
     //如果传入的index大于当前链表的长度/2，则从右往左查找
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

add()方法

public boolean add(E e) {
    linkLast(e);
    return true;
}
//将添加的节点挂在链表尾部
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
  }

get()方法

直接返回下标节点绑定的元素

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

remove()方法

LinkedList的remove()方法同样有下标移除和对象移除
下标移除：

public E remove(int index) {
    checkElementIndex(index);
    //查找下标位置的元素，然后解除链接
    return unlink(node(index));
}

对象移除，首先遍历查找到对应的元素，然后解除链接：

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

看一下解除链接的方法：

E unlink(Node<E> x) {
	//获取x中的元素，上个节点和下个节点
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    //上个节点如果是空，则x是头结点，设置下个节点为头结点；如果上个节点不是空，将上个节点和下个节点绑定在一起
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }
     //下个节点如果是空，则x是尾结点，设置上个节点为尾结点；如果下个节点不是空，将上个节点和下个节点绑定在一起
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
	//将X元素位置的引用设置为null，上面也将x的上下节点之间的链接断开了，都设置为null了，则x完全解除了，垃圾回收的时候会回收掉
    x.item = null;
    size--;
    modCount++;
    return element;
}

size()方法同样不说了，虽然链表没有长度，LinkedList内部有个size一直记录着当前存了多少元素了。