JAVA系列集合之-LinkedList

1. LinkedList 简介

• LinkedList 是链表结构，和ArrayList相比使用场景有所区别，因为ArrayList是数组结构，所以在查找数据的性能上是很好的，但是LinkedList是链表结构，所以已在查询上的性能不是很理想，但是在插入和删除的性能是很好的
• LinkedList继承了AbstractSequentialList、实现了List、Deque、Cloneable、Serializable接口
  • 继承了List的接口并且实现了AbstractSequentialList，LinkedList就有了增、删、改、查、等功能
  • 实现了Deque则说明有链表的有序性，但是相关的add、remove方式已经在LinkedList都给重写了
  • 实现了Cloneable接口则说明ArrayList支持Object的clone的方法，如果不继承调用clone方法会抛出CloneNotSupportedException的错误，看了下源码，是native方法实现的
  • 实现了Serializable接口则说明ArrayList能够被序列化和反序列化，能够在网络中进行传输
• 从LinkedList的源码中可以看到，没有任何锁的添加，所以LinkedList是非线程安全的

2.LinkedList的数据结构

LinkedList的集成关系

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
              ↳        java.util.AbstractSequentialList
                   ↳         java.util.ArrayList<E>

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

在LinkedList有如下几个重要的属性：

• size：集合的长度，在add和remove节点的时候会随着更新
• first：双向链表的头部节点
• last：双向量小的尾部节点

针对first元素和last元素，对应的是在LinkedList中的一个静态内部类，结构为

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

改静态内部类也是存储数据构成链表节点的类，item是保存数据，next保存下一个节点的指针的地址，prev是上一个节点的指针地址

 

3.LinkedList的常用方法

1. get(int index)

我们知道随机读取元素不是LinkedList所擅长的，读取效率比起ArrayList也低得多，那么来看一下为什么

public E get(int index) {
　　//检查是否超过最大长度，超过则抛错
    checkElementIndex(index);
    return node(index).item;
}

/**
 * 返回一个指定索引的非空节点.
 */
Node<E> node(int index) {
    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;
    }
}

从上述代码中我们可以看到get(int index)方法是通过node(int index)来实现的，它的实现机制是：

比较传入的索引参数index与集合长度size/2，如果是index小，那么从第一个顺序循环，直到找到为止；如果index大，那么从最后一个倒序循环，直到找到为止。也就是说越靠近中间的元素，调用get(int index方法遍历的次数越多，效率也就越低，而且随着集合的越来越大，get(int index)执行性能也会指数级降低。因此在使用LinkedList的时候，我们不建议使用这种方式读取数据，可以使用getFirst()，getLast()方法，将直接用到类中的first和last变量。

2. add(E e) 和 add(int index, E element)

大家都在说LinkedList插入、删除操作效率比较高，以stringList.add(“猪八戒”)为例来看到底发生了什么？

在LinkedList中我们找到add(E e)方法的源码

public boolean add(E e) {
    linkLast(e);
    return true;
}

/**
 * 设置元素e为最后一个元素，使用的尾插发将元素放入
*/
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++;
}

很好理解：

情况1：假如stringList为空，那么添加进来的node就是first，也是last，这个node的prev和next都为null;

 

情况2：假如stringList不为空，那么添加进来的node就是last，node的prev指向以前的最后一个元素，node的next为null；同时以前的最后一个元素的next.

 

因为画图太麻烦，此处借鉴了https://www.cnblogs.com/LiaHon/p/11107245.html

而如果通过stringList.add(1, “猪八戒”)这种方式将元素添加到集合中呢？

 

//在指定位置添加一个元素
public void add(int index, E element) {
    checkPositionIndex(index);
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

/**
 * 在一个非空节点前插入一个元素
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

其实从代码中看到和add(E e)的代码实现没有本质区别，都是通过新建一个Node实体，同时指定其prev和next来实现，不同点在于需要调用node(int index)通过传入的index来定位到要插入的位置，这个也是比较耗时的，参考上面的get(int index)方法。

其实看到这里，大家也都明白了。

• LinkedList插入效率高是相对的，因为它省去了ArrayList插入数据可能的数组扩容和数据元素移动时所造成的开销，但数据扩容和数据元素移动却并不是时时刻刻都在发生的。

3. remove(Object o) 和 remove(int index)

这里removeFirst()和removeLast()就不多说了，会用到类中定义的first和last变量，非常简单，我们看一下remove(Object o) 和 remove(int 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;
}
//删除某个位置的元素
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 {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}