Java集合类详解（二）

上一篇介绍了ArrayList，这一篇介绍LinkedList。

1.2 LinkedList

LinkedList适用于集合元素先入先出和先入后出的场景，其底层是一个双向链表，整体结构如下图所示：

LinkedList有几个概念：

• 链表每个节点叫做Node，Node有prev属性，代表前一个节点，next属性代表后一个节点，item表示这个Node的值；
• first是双向链表的头节点，它的前一个节点是null；
• last是双向链表的尾节点，它的后一个节点是null；
• 当链表中没有数据时，first和last是同一个节点，前后都指向null；
• 因为是双向链表，只要机器内存足够大，是没有大小限制的，而ArrayList的最大值是Integer.MAX_VALUE；

1.2.1 add()方法

add()方法默认从尾部开始追加，源码如下：

// 从尾部开始追加节点
void linkLast(E e) {
    // 把尾节点数据暂存
    final Node<E> l = last;
    // 新建节点，l是新节点的前一个节点，当前值是尾节点值，e表示当前新增节点，当前新增节点后一个节点是 null
    final Node<E> newNode = new Node<>(l, e, null);
    // 新建节点追加到尾部
    last = newNode;
    //如果链表为空（l 是尾节点，尾节点为空，链表即空），头部和尾部是同一个节点，都是新建的节点
    if (l == null)
        first = newNode;
    //否则把前尾节点的下一个节点，指向当前尾节点。
    else
        l.next = newNode;
    //大小和版本更改
    size++;
    modCount++;
}

1.2.1 addFirst()方法

addFirst()方法是指从头部追加，源码如下：

private void linkFirst(E e) {
    // 暂存头节点
    final Node<E> f = first;
    // 新建节点，前一个节点指向null，e是新建节点，f是新建节点的下一个节点，目前值是头节点的值
    final Node<E> newNode = new Node<>(null, e, f);
    // 新建节点成为头节点
    first = newNode;
    // 头节点为空，就是链表为空，头尾节点是一个节点
    if (f == null)
        last = newNode;
    //上一个头节点的前一个节点指向当前节点
    else
        f.prev = newNode;
    size++;
    modCount++;
}

头部追加节点和尾部追加节点类似，前者改变了头节点prev的指向，后者则改变了为节点的next指向。

1.2.2 删除节点

删除节点可以选择从头部删除，也可以从尾部删除，删除操作会把当前节点的值，前后的指向置为null。
从头部删除的源码如下：

    private E unlinkFirst(Node<E> f) {
        // 拿出头节点，作为返回值
        final E element = f.item;
        // 拿出头节点的下一个节点
        final Node<E> next = f.next;
        // 把头节点的值和next指向置为null，用于GC回收
        f.item = null;
        f.next = null; // help GC
        // 把头节点下一个节点作为新的头节点
        first = next;
        // 如果next为null，表明链表为空
        if (next == null)
            last = null;
        // 如果next不为null，把头节点的前一个节点指向null  
        else
            next.prev = null;
        //修改链表大小和版本
        size--;
        modCount++;
        return element;
    }

链表结构的节点新增、删除仅仅是把前后节点的指向修改下就好了，所以LinkedList的新增和删除速度很快。

1.2.3 查询节点

    Node<E> node(int index) {
        // 如果index处于链表的前半部分，则从头开始找
        if (index < (size >> 1)) {
            Node<E> x = first;
            // 执行for循环，直到index的前一个位置，将节点返回
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        //如果index处于链表的后半部分，则从尾开始找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

可以看出，链表的查找使用了二分查找法，提高了查询的效率。

1.2.4 总结

LinkedList 适合增删多，随机访问少的场景，因为使用LinkedList进行查询时，需要从头进行查找，效率较低，而增删时，只需要改变当前节点的指向即可。