LinkedList源码解析

引言

在前面的文章中, 我们对 ArrayList 做了较为详细的源码解读, 今天将在这篇文章中继续对 LinkedList 的源码作出解读, 本文中的 LinkedList 是基于 jdk1.8.

LinkedList 底层分析

LinkedList 数据结构

如上图所示 LinkedList 底层是基于双向链表实现的, 其中 LinkedList 的头结点不存放数据, 仅存放指针.

常用字段

transient int size = 0;// 当前 LinkedList 对象中存储的数据数目
transient Node first;// 起始节点
transient Node last;// 结束节点
以上的三个字段全都使用了transient关键字进行修饰, 因为该三个字段可能为空, 以免在自动序列化中引起错误使得序列化失败

常用方法

add(E e)

将元素插入链表末尾

 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;// 若链表为空链表, 将新节点赋值给给 first 节点
    else
        l.next = newNode;
    size++;
    modCount++;
}  

由源码可见每次插入数据都是移动指针，相比 ArrayList的拷贝数组来说效率要高上不少。时间复杂度为o(1)

add(int index, E element)

将元素插入链表指定位置

  public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

  Node<E> node(int index) {
      // assert isElementIndex(index);
     //判断index是否大于1/2的size,若小于1/size则从first结点开始向后遍历,否则从last节点开始向前遍历
      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;
      }
  } 

上述代码，利用了双向链表的结构特点 (可双向遍历)，如果index离链表头比较近，就从节点头部遍历。否则就从节点尾部开始遍历。使用空间（双向链表的每个节点的前后指针所占用空间）来换取时间。

• node()会以O(n/2)的时间复杂度去获取一个结点
• 如果索引值大于链表大小的一半，那么将从尾结点开始遍历

这样的效率是非常低的，特别是当 index 越接近 size 的中间值时。

get(int index)

获取指定索引的元素

public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
 Node<E> node(int index) {
        // assert isElementIndex(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()方法和前面的add(int index, E element)一样, 需要调用到node(int index)方法进行查找.

peek()和 poll()

peek()方法和poll()是如果 list 中的开始节点, 但peek()方法不会将节点从链表中移除, 而poll()方法会.

public E peek() {
   final Node<E> f = first;
   return (f == null) ? null : f.item;
}

public E poll() {
   final Node<E> f = first;
   return (f == null) ? null : unlinkFirst(f);
} 

其余方法如writeObject(),``readObject()方法与ArrayList中的方法类似, 此处不做过多介绍.

最后的思考题

现有一个LinkedList类型的list,其中含有顺序[1....100000]个元素(10w),现在要打印后10000个元素,如下操作方式会有什么方面的问题? 
for(int i = 90000; i<list.size(); i++){
    System.out.println(list.get(i)); 
} 

具体答案可以参考LinkedList 下的错误操作, 这篇文章就这么结束了, 似乎写的有点水啊! 读者觉得有什么需要补充的欢迎在下面留言.