深入底层LinkedList源码解析

LinkedList源码解析

LinkedList的底层实现
双向链表：由一系列的结点组成，每个结点分为三个部分，一个是存储前继节点地址的指针域，一个是存储数据元素的数据域，最后一个是存储后继结点地址的指针域。
顺便提一下单向链表：由一系列的结点组成，与双向链表不同的是，单向链表没有存储前继结点地址的指针域，其余部分相同。

构造方法

LinkedList的构造方法
空构造方法和带参构造方法
空构造方法就是创建一个空的LinkedList链表，带参数的构造方法就是将参数(Collection c)c中的所有元素循环添加到LinkedList链表中。

添加add()方法

 //默认的添加就是添加尾部   
public boolean add(E e) {   
     linkLast(e);     //调用了linkLast()方法
     return true;
}

//这边看一下linkLast()方法的源码
void linkLast(E e) {//e这个就是add方法中传入的参数
     final Node<E> l = last;  //定义一个l结点,标识为尾结点（last）
     //创建一个e结点，参数l(前继结点) e(新节点) null(后继结点) 形成链子
     final Node<E> newNode = new Node<>(l, e, null);
     //然后将新的这个结点e赋值给last，也就是此时尾结点为新创建的结点e
     last = newNode;
     //判断last结点是否为null，为null则说明没有尾结点，也就是说该链表中没有元素
     if (l == null)
         first = newNode;//为null，那么此时链表的头结点也是新的e结点
     else
         l.next = newNode;//不为null，那么将之前的尾结点l的后继结点指向新创建的e结点
     size++;//链表大小++
     modCount++;//链表修改次数++
 }

add(int index,E element)方法
指定下标的添加，也就是插入

//add(int index,E element)源码
public void add(int index, E element) {
    checkPositionIndex(index); //检查传入的下标是否正确
    if (index == size)//判断下标是否等于链表的大小，相等的话就是尾部插入，调用linkLast()方法
        linkLast(element);
    else
    //不相等的时候，调用 linkBefore()方法，并传入你要插入的elemnet元素和当前index位置上的元素
        linkBefore(element, node(index));
}

//checkPositionIndex()方法源码
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))  //下标不正确 就抛出IndexOutOfBoundsException异常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//linkBefore()方法源码
//传入的两个参数，e要插入的结点，succ链表当前index位置的结点
void linkBefore(E e, Node<E> succ) {
    final Node<E> pred = succ.prev;//获取当前index位置结点的前继结点
    //创建新节点e，他的前继结点为pred，也就是原位置的前继结点，后继结点为元结点succ
    final Node<E> newNode = new Node<>(pred, e, succ);
    //将原结点的前继结点指向新创建的结点e
    succ.prev = newNode;
    //判断succ原结点的前继结点是不是为null
    if (pred == null)
    //假如没有前继结点，那么说明插入的位置就是头部，将新结点赋值给first，也就是链表的头
        first = newNode;
    else
    //反之，就是将原结点的前继结点的后继结点指向新的结点  形成链子
        pred.next = newNode;
    size++;//链表大小++
    modCount++;//修改次数++
}

//再来看一下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;
    }
}

add()方法看完了，接下来看看remove()方法
remove()

//不带参数的remove()方法 默认删除头部结点，调用了removeFirst()方法
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)//判断头结点是否为空，其实就是判断链表是否为空
    //为空则抛出NoSuchElementException异常
        throw new NoSuchElementException();
        //如果有元素存在，那么调用unlinkFirst()方法解开链子
    return unlinkFirst(f);
}

//在说unlinkFirst之前先说一下unlink()方法
E unlink(Node<E> x) {
    final E element = x.item;  //获取x结点的元素
    final Node<E> next = x.next; //获取x的后继结点
    final Node<E> prev = x.prev; //获取x的前继结点
	//判断x的前继结点是否存在
    if (prev == null) {
    //不存在前继结点的话，将头结点赋值为他的后继结点
        first = next;
    } else {
    //存在前继结点的话，将x的前继结点的后继结点赋值为x的后继结点，然后将x与前继结点的连接断开
        prev.next = next;
        x.prev = null;
    }
//同理判断x的后继结点是否存在 ，这边就不一一细说了
    if (next == null) {
         last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
//x的前继和后继结点都断开连接后，将x的元素设为null，那么GC就会回收
    x.item = null;
    size--;//链表大小--
    modCount++;//修改此时++
    return element;//返回被删除的元素
}

//理解了unlink，那么unlinkFirst 和unlinkLast 就很好理解了
//删除头结点
private E unlinkFirst(Node<E> f) {
    final E element = f.item; //获取要删除的元素  最后返回
    final Node<E> next = f.next;//获取该元素的后继结点
    f.item = null; //将结点的元素置空
    f.next = null; // 断开他和后继结点的链子 方便GC回收 help GC
    first = next; //将头结点给该结点的后继结点
    //判断后继结点是否存在
    if (next == null)
    //如果没有后继结点  说明该链表中只有一个元素，被删除之后，那么last也设为null
        last = null;
    else
    //反之将该元素的后继结点的前继结点设为null，就是断开和该元素的连接
        next.prev = null;
    size--; //大小--
    modCount++; //修改次数++
    return element;  //返回被删除的头元素
}
//这是删除为结点  和删除头结点一样
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}


那么之后的removeFirst  和  removeLast就是分别调用了上面的unlinkFirst和unlinkLast方法

接着说一下查询方法get()

//get()方法的源码
 public E get(int index) {
    checkElementIndex(index); //先调用checkElementIndex()方法检查该下标是否正确
    return node(index).item; //这边调用了node方法，并返回内容item
}
//checkElementIndex()方法
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//node()方法
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 {
    //如果大于size的一半，那么久从链表的尾部开始查找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}