JAVA集合框架源码分析3-LinkedList

java中的数据结构之集合框架源码分析的系列文章如下：
JAVA集合框架源码分析1-ArrayList
JAVA集合框架源码分析2-Stack
JAVA集合框架源码分析3-LinkedList
数据结构中有多种存储结构，如表和树，表中典型的是线性表，这种数据结构在java中最常见的就是ArrayList（顺序表）和LinkedList(链表)，本文将着重对LinkedList的源码进行分析

1.继承关系

public class LinkedListextends AbstractSequentialList
    implements List, Deque, Cloneable, java.io.Serializable

public abstract class AbstractSequentialList extends AbstractList

public interface Deque extends Queue

如上所示
AbstractSequentialList是AbstractList的抽象子类
Deque是Queue的子接口，Queue是一个队列，我们先来看看Queue中的方法

public interface Queue extends Collection {
   
    boolean add(E e);
    boolean offer(E e);//建议使用

    E remove();
    E poll(); //建议使用

    E element();
    E peek();//建议使用
}

（1）offer，add区别：

一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。

这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。

（2）poll，remove区别：

remove() 和 poll() 方法都是从队列中删除第一个元素。remove() 的行为与 Collection 接口的版本相似，

但是新的 poll() 方法在用空集合调用时不是抛出异常，只是返回 null。因此新的方法更适合容易出现异常条件的情况。

（3）peek，element区别：

element() 和 peek() 用于在队列的头部查询元素。element()与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null

接下来看下Deque

public interface Deque extends Queue {
   
    void addFirst(E e);
    void addLast(E e);

    boolean offerFirst(E e);
    boolean offerLast(E e);

    E removeFirst();
    E removeLast();

    E pollFirst();
    E pollLast();

    E getFirst();
    E getLast();

    E peekFirst();
    E peekLast();

    boolean removeFirstOccurrence(Object o);
    boolean removeLastOccurrence(Object o);

    // *** Queue methods ***队列的方法

    boolean add(E e);
    boolean offer(E e);
 
    E remove();
    E poll();

    E element();
    E peek();


    // *** Stack methods ***以下两个方法可实现类似于栈的功能

    //等同于addFirst，如果一直使用这个方法添加元素类似于压栈操作
    void push(E e);

  //等同于removeFirst，如果一直使用这个方法删除元素类似于出栈操作
    E pop();


    // *** Collection methods ***

  
    //等同于removeFirstOccurrence
    boolean remove(Object o);

    boolean contains(Object o);

    public int size();

好的，接下来就是今天的主角了，LinkedList

2.成员变量

    //l链表元素个数
    transient int size = 0;
    //头部结点
    transient Node first;
   //尾部节点
    transient Node last;

接下来我们看下这个节点类里面都有什么信息

private static class Node {
        //节点中的数据
        E item;
        //下一个节点
        Node next;
        //上一个节点
        Node prev;

        Node(Node prev, E element, Node next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

节点中包含上一个节点的引用和下一个节点的引用，由此可见LinkedList是一个双向链表

3.构造函数

  public LinkedList() {
    }

    //将现有的集合添加到当前的链表中
    public LinkedList(Collection c) {
        this();
        addAll(c);
    }

public boolean addAll(Collection c) {
        return addAll(size, c);
    }

public boolean addAll(int index, Collection c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node pred, succ;
        //第一次插入，或者插入在尾部
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            //根据要插入节点的位置找到index位置的节点
            succ = node(index);
            //找到index位置节点的上一个节点，以便于在其之后插入新的节点
            pred = succ.prev;
        }

        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node newNode = new Node<>(pred, e, null);
            //要在链表头部插入节点
            if (pred == null)
                first = newNode;
            else
                //将index位置之前的节点的next引用指向新节点，
                pred.next = newNode;
                //将pred引用指向新节点，便于下一次操作增加节点的操作
                pred = newNode;
        }

        if (succ == null) {
            last = pred;//将last引用指向最后一个Node（第一次添加时候或添加在尾部时候）
        } else {
            pred.next = succ; //将添加后的最后一个Node的next指向原链表index位置的Node
            succ.prev = pred;//同时将原链表index位置的Node的prev 指向添加后的最后一个Node
        }
        //链表长度增加
        size += numNew;
        modCount++;
        return true;
    }

4.操作——增加

第一种增加方法（默认添加到链表的尾部）

public boolean add(E e) {
        linkLast(e);
        return true;
    }
//将元素添加到链表的尾部
 void linkLast(E e) {
        final Node l = last;
        final Node newNode = new Node<>(l, e, null);//此处构造时已经新节点的pre引用指向了原链表的最后一个节点。
        last = newNode;
        if (l == null)
            //原链表为空，则将头结点指向新节点，此时头结点和尾节点都是这个新节点
            first = newNode;
        else
            //将原链表的最后一个节点的next引用指向新节点
            l.next = newNode;
        size++;
        modCount++;
    }

第二种增加方法（添加到链表尾部）

public void addLast(E e) {
        //同上，只是没有返回值
        linkLast(e);
    }

第三种增加方法（添加到链表的头部）

 public void addFirst(E e) {
        linkFirst(e);
    }

private void linkFirst(E e) {
        final Node f = first;
        final Node newNode = new Node<>(null, e, f);//此处构造时已经新节点的next引用指向了原链表的第一个节点。
        first = newNode;
        if (f == null)
            //头节点为null，则头结点和尾节点都是新元素
            last = newNode;
        else
            //将头结点的prev指向新节点
            f.prev = newNode;
        size++;
        modCount++;
    }

第四种增加方法（在指定位置增加节点）

public void add(int index, E element) {
        //检查添加位置是否合法
        checkPositionIndex(index);
        //添加的位置是尾部
        if (index == size)
            linkLast(element);
        else
            //在指定位置添加
            linkBefore(element, node(index));
    }

void linkBefore(E e, Node succ) {
        // assert succ != null;
        final Node pred = succ.prev; //将pred引用指向原index位置的节点的上一个一点
        final Node newNode = new Node<>(pred, e, succ); //创建新节点，将新节点的prev指向pred，next指向原index位置的节点succ
        //将succ上一个节点引用指向添加的节点
        succ.prev = newNode;
        if (pred == null)
            //添加的位置在头部，
            first = newNode;
        else
             //原index-1位置的节点pred的下一个节点指向新节点
            pred.next = newNode;
        size++;
        modCount++;
    }

另外对于Deque的其他的增删改查的实现方法不做过多的解释，读者可以自行查看源码，很简单的。

5.操作——删除

第一种删除方法

public E remove(int index) {
        //检查删除位置是否合法
        checkElementIndex(index);
        //对于根据位置找到节点的方法在下面查找的方法中会做解释，查找方式还是不错的，
        return unlink(node(index));
    }

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

        if (prev == null) {
          //删除的是头结点，则让first引用指向下一个节点
            first = next;
        } else {
            //删除元素的上一个元素的next引用指向删除元素的下一个节点
            prev.next = next;
            //将删除元素的prev引用设为null。便于GC回收
            x.prev = null;
        }

        if (next == null) {
            //删除的是尾节点，则让last引用指向上一个节点
            last = prev;
        } else {
             //删除节点的下一个节点的prev引用指向删除节点的上一个节点
            next.prev = prev;
          //将删除元素的next引用设为null。便于GC回收
            x.next = null;
        }

        x.item = null;//将删除元素的数据引用设为null。便于GC回收
        size--; 
        modCount++;
        return element;
    }

第二种删除方法

//remove(Object o)这个删除元素的方法的形参o是item，而不是LinkedList集合中的元素（节点）
public boolean remove(Object o) {
        //此处表示节点的数据可以为null
        if (o == null) {
            //通过节点遍历的方式，找到o数据对应的元素
            for (Node x = first; x != null; x = x.next) {
                if (x.item == null) {
                    //同上进行删除
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

6.操作——查找

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

Node node(int index) {
        // assert isElementIndex(index);
        //size >> 1操作可以将链表分为两部分，这样加快了查找的效率
        //从前向后查找
        if (index < (size >> 1)) {
            Node x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            //从后向前查找
            Node x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

7.操作——修改

 public E set(int index, E element) {
        checkElementIndex(index);
        //根据位置查找到要修改的节点
        Node x = node(index);
        
        E oldVal = x.item;
        //给当前节点的数据重新赋值
        x.item = element;
        //返回修改前的节点的数据
        return oldVal;
    }

8.总结

1.LinkedList是基于链表的数据结构实现的是一个双向链表，并实现了Queue，所以LinkedList也是一个队列
2.LinkedList中的元素就是一个个的节点，数据的存放是以Node作为载体的。
3.LinkedList数据结构形式导致查找和修改需要遍历集合中的元素，效率比ArrayList低，但是增加和删除效率比较高