JDK1.8源码学习-LinkedList

目录

一、LinkedList简介

LinkedList是一个继承于AbstractSequentialList的双向链表,是可以在任意位置进行插入和移除操作的有序序列。

LinkedList基于链表实现,在存储元素的过程中,无需像ArrayList那样进行扩容,但是有得必有失,LinkedList存储元素的节点需要额外的空间存储前驱和后继的引用。此外,LinkedList在链表头部和尾部插入效率比较高,但是在指定位置进行插入操作时,效率一般。原因是在指定位置插入需要定位到该位置处的节点,此操作的时间复杂度为O(N)。

二、LinkedList工作原理

在LinkedList中,每一个元素都是Node存储,Node拥有一个存储值的item和一个前驱prev和一个后继next,源码如下:

// 链表结构
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;
}
}

三、LinkedList源码分析

3.1、继承关系分析

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

LinkedList继承自AbstractSequentialList,实现了List、Deque、Cloneable、Serializable接口,其中List接口中定义了一些队列的基本的操作,Deque接口能够使LinkedList当作双端队列使用,Cloneable接口可以使LinkedList调用clone()方法,进行浅层次的拷贝,Serializable接口可以使LinkedList实现序列化。

3.2、成员变量分析

//实现Serilizable接口时,将不需要序列化的属性前添加关键字transient,
//序列化对象的时候,这个属性就不会序列化到指定的目的地中。
transient int size = 0;
//指向首节点
transient Node<E> first;
//指向最后一个节点
transient Node<E> last;

3.3、构造函数分析

3.3.1 无参构造函数

    //无参的构造函数
public LinkedList() {
}

3.3.2 传入集合c的构造函数

    public LinkedList(Collection<? extends E> c) {
this();
// 将集合添加到链表中去
addAll(c);
} public boolean addAll(Collection<? extends E> c) {
// 从链表尾巴开始添加集合中的元素
return addAll(size, c);
} public boolean addAll(int index, Collection<? extends E> c) {
// 1.添加位置的下标的合理性检查
checkPositionIndex(index); // 2.将集合转换为Object[]数组对象
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false; // 3.得到插入位置的前继节点和后继节点
Node<E> pred, succ;
if (index == size) {
// 从尾部添加的情况:前继节点是原来的last节点;后继节点是null
succ = null;
pred = last;
} else {
// 从指定位置(非尾部)添加的情况:前继节点就是index位置的节点,后继节点是index位置的节点的前一个节点
succ = node(index);
pred = succ.prev;
} // 4.遍历数据,将数据插入
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
// 创建节点
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
// 空链表插入情况:
first = newNode;
else
// 非空链表插入情况:
pred.next = newNode;
// 更新前置节点为最新插入的节点(的地址)
pred = newNode;
} if (succ == null) {
// 如果是从尾部开始插入的,则把last置为最后一个插入的元素
last = pred;
} else {
// 如果不是从尾部插入的,则把尾部的数据和之前的节点连起来
pred.next = succ;
succ.prev = pred;
} size += numNew; // 链表大小+num
modCount++; // 修改次数加1
return true;
}

3.4、add()方法分析

LinkedList中的add方法有两个,一个是add(E e)方法,一个是add(int index, E element)方法。

3.4.1、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节点也为需要插入的节点。(也就是说:该节点既是头节点first也是尾节点last)
first = newNode;
else
// 不是空链表的情况:将原来的尾部节点(现在是倒数第二个节点)的next指向需要插入的节点
l.next = newNode;
size++; // 更新链表大小和修改次数,插入完毕
modCount++;
}

3.4.2、add(int index,E element)方法

    // 作用:在指定位置添加元素
public void add(int index, E element) {
// 检查插入位置的索引的合理性
checkPositionIndex(index); if (index == size)
// 插入的情况是尾部插入的情况:调用linkLast()。
linkLast(element);
else
// 插入的情况是非尾部插入的情况(中间插入):linkBefore()见下面。
linkBefore(element, node(index));
} private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
} private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
} 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的前节点,后接点是succ节点
succ.prev = newNode; // 更新插入位置(succ)的前置节点为新节点
if (pred == null)
// 如果pred为null,说明该节点插入在头节点之前,要重置first头节点
first = newNode;
else
// 如果pred不为null,那么直接将pred的后继指针指向newNode即可
pred.next = newNode;
size++;
modCount++;
}

3.5、get(int index)方法分析

    public E get(int index) {
// 元素下表的合理性检查
checkElementIndex(index);
// node(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;
}

3.6、remove(int index)方法分析

    // 作用:移除指定位置的元素
public E remove(int index) {
// 移除元素索引的合理性检查
checkElementIndex(index);
// 将节点删除
return unlink(node(index));
} E unlink(Node<E> x) {
// assert x != null;
final E element = x.item; // 得到指定节点的值
final Node<E> next = x.next; // 得到指定节点的后继节点
final Node<E> prev = x.prev; // 得到指定节点的前继节点 // 如果prev为null表示删除是头节点,否则就不是头节点
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null; // 置空需删除的指定节点的前置节点(null)
} // 如果next为null,则表示删除的是尾部节点,否则就不是尾部节点
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null; // 置空需删除的指定节点的后置节点
} // 置空需删除的指定节点的值
x.item = null;
size--; // 数量减1
modCount++;
return element;
}

3.7、clear()方法分析

       // 清空链表
public void clear() {// 进行for循环,进行逐条置空;直到最后一个元素
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
// 置空头和尾为null
first = last = null;
size = 0;
modCount++;
}

3.8、indexOf(Object o)方法分析

  // 返回列表中第一次出现o的位置,若不存在则返回-1
public int indexOf(Object o) {
int index = 0;
// 如果元素为null,进行如下循环判断
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
// 元素不为null.进行如下循环判断
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}

3.9、addFirst(E e)方法分析

   // 作用:在链表头插入指定元素
public void addFirst(E e) {
linkFirst(e);
} private void linkFirst(E e) {
final Node<E> f = first; // 获取头部元素
final Node<E> newNode = new Node<>(null, e, f); // 创建新的头部元素(原来的头部元素变成了第二个)
first = newNode; // 链表头部为空,(也就是链表为空)
if (f == null)
last = newNode; // 头尾元素都是e
else
f.prev = newNode; // 否则就更新原来的头元素的prev为新元素的地址引用
size++;
modCount++;
}

3.10、addLast(E e)方法分析

    // 作用:在链表尾部添加元素e
public void addLast(E e) {
// 上面已讲解过,参考上面。add()方法
linkLast(e);
}

3.11、push(E e)方法分析

  // 作用:将元素添加到头部(入栈)
public void push(E e) {
addFirst(e);
} public void addFirst(E e) {
linkFirst(e);
} private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}

3.12、getFirst()方法分析

    // 作用:得到头元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}

3.13、getLast()方法分析

    // 作用:得到尾部元素
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}

3.14、peek()方法分析

    // 作用:返回头元素,并且不删除。如果不存在也不错,返回null
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}

3.15、peekFirst()方法分析

    //  作用:返回头元素,并且不删除。如果不存在也不错,返回null
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}

3.16、peekLast()方法分析

    // 作用:返回尾元素,如果为null,则就返回null
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}

3.17、poll()方法分析

    // 作用:返回头节点元素,并删除头节点。并将下一个节点设为头节点。
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}

3.18、pollFirst()方法分析

    // 作用:返回头节点,并删除头节点,并将下一个节点设为头节点。
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}

3.19、pollLast()方法分析

    // 作用:返回尾节点,并且将尾节点删除,并将尾节点的前一个节点置为尾节点
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}

3.20、pop()方法分析

    // 作用:删除头节点,如果头结点为null.则抛出异常(出栈)
public E pop() {
return removeFirst();
} public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

四、利用LinkedList实现栈操作

public class Stack<T>
{
private LinkedList<T> stack; //无参构造函数
public Stack()
{
stack=new LinkedList<T>();
}
//构造一个包含指定collection中所有元素的栈
public Stack(Collection<? extends T> c)
{
stack=new LinkedList<T>(c);
}
//入栈
public void push(T t)
{
stack.addFirst(t);
}
//出栈
public T pull()
{
return stack.remove();
}
//栈是否为空
boolean isEmpty()
{
return stack.isEmpty();
} //打印栈元素
public void display()
{
for(Object o:stack)
System.out.println(o);
}
}

五、LinkedList总结

ArrayList和LinkedList的大致区别:

1.ArrayList是基于动态数组的数据结构,LinkedList是基于链表的数据结构。

2.对于随机访问的get和set方法,ArrayList要优于LinkedList,因为LinkedList要移动指针。

3.数组遍历的方式ArrayList推荐使用for循环,而LinkedList则推荐使用forearch,如果使用for循环,效率会很慢。

一般来说,对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据,但是这样说是有一些问题的。

     LinkedList做插入、删除的时候,慢在寻址,快在只需要改变前后的Node的引用地址;

    ArrayList做插入、删除的时候,慢在数组元素的批量copy,快在寻址。

所以,如果待插入、删除的元素是在数据结构的前半段尤其是非常靠前的位置的时候,LinkedList的效率将大大快过ArrayList,因为ArrayList将批量copy大量的元素;越往后,对于LinkedList来说,因为它是双向链表,所以在第2个元素后面插入一个数据和在倒数第2个元素后面插入一个元素在效率上基本没有差别,但是ArrayList由于要批量copy的元素越来越少,操作速度上必然追上乃至超过LinkedList。

在实际中应该怎样选择呢?

  如果你十分确定你插入、删除的元素是在前半段,使用LinkedList,反之使用ArrayList。

       如果不确定,建议使用LinkedList,因为LinkedList整体插入、删除的执行效率比较稳定,没有ArrayList这种越往后越快的情况,且ArrayList可能会进行扩容,扩容是一件即消耗时间又消耗空间的操作。

JDK1.8源码学习-LinkedList的更多相关文章

  1. JDK1.8源码学习-String

    JDK1.8源码学习-String 目录 一.String简介 String类是Java中最常用的类之一,所有字符串的字面量都是String类的实例,字符串是常量,在定义之后不能被改变. 二.定义 p ...

  2. JDK1.8源码学习-Object

    JDK1.8源码学习-Object 目录 一.方法简介 1.一个本地方法,主要作用是将本地方法注册到虚拟机中. private static native void registerNatives() ...

  3. JDK1.8源码学习-ArrayList

    JDK1.8源码学习-ArrayList 目录 一.ArrayList简介 为了弥补普通数组无法自动扩容的不足,Java提供了集合类,其中ArrayList对数组进行了封装,使其可以自动的扩容或缩小长 ...

  4. JDK1.8源码学习-HashMap

    JDK1.8源码学习-HashMap 目录 一.HashMap简介 HashMap 主要用来存放键值对,它是基于哈希表的Map接口实现的,是常用的Java集合之一. 我们都知道在JDK1.8 之前 的 ...

  5. JDK源码学习LinkedList

    LinkedList是List接口的子类,它底层数据结构是双向循环链表.LinkedList还实现了Deque接口(double-end-queue双端队列,线性collection,支持在两端插入和 ...

  6. jdk1.8源码学习笔记

    前言: 前一段时间开始学习了一些基本的数据结构和算法,算是弥补了这方面的知识短板,但是仅仅是对一些算法的了解,目前工作当中也并没有应用到这些,因此希望通过结合实际例子来学习,巩固之前学到的内容,思前想 ...

  7. Java JDK1.8源码学习之路 1 Object

    写在最前 对于一个合格的后端程序员来说,现行的流行框架早已经能胜任基本的企业开发,Springboot 任何的框架都把重复的工作更佳简单/优化的解决掉,但是完全陷入在这样的温水里面, 好比温水煮青蛙, ...

  8. Java JDK1.8源码学习之路 2 String

    写在最前 String 作为我们最常使用的一个Java类,注意,它是一个引用类型,不是基本类型,并且是一个不可变对象,一旦定义 不再改变 经常会定义一段代码: String temp = " ...

  9. JDK1.8源码学习-String-hashCode方法为什么选择数字31作为乘子

    1. 背景 某天,我在写代码的时候,无意中点开了 String hashCode 方法.然后大致看了一下 hashCode 的实现,发现并不是很复杂.但是我从源码中发现了一个奇怪的数字,也就是本文的主 ...

随机推荐

  1. ST表解决RMQ问题

    RMQ问题: RMQ(Range Minimum/Maximum Query),区间最值查询.对于长度为n的数列A,回答若干询问RMQ(A,i,j)(i,j<=n),返回数列A中下标在i,j之间 ...

  2. jQuery中常用网页效果应用

    一.常用网页效果应用 1.表单应用 表单由表单标签.表单域和表单按钮组成. 1.1单行文本框应用 例:获取和失去焦点改变样式 首先,在网页中创建一个表单,HTML代码如下 <form actio ...

  3. Head First HTML与CSS(第2版)PDF高清完整版免费下载|百度云盘

    百度云盘:Head First HTML与CSS(第2版)PDF高清完整版免费下载 提取码:i8q4 内容简介 是不是已经厌倦了那些深奥的HTML书?你可能在抱怨,只有成为专家之后才能读懂那些书.那么 ...

  4. 启动扫描闪退,因为忘了在manifest里申请手机镜头使用许可了。

    启动扫描闪退,因为忘了在manifest里申请手机镜头使用许可了.

  5. 爬虫(三)-之Urllib库的基本使用

    什么是Urllib Urllib是python内置的HTTP请求库 包括以下模块 urllib.request 请求模块 urllib.error 异常处理模块 urllib.parse   url解 ...

  6. 想学Python不知道从哪里开始学?|百度网盘免费下载| 这本入门书了解下

    百度网盘免费下载:编程小白的第一本 Python 入门书 提取码:s0pc Python是什么 Python是一种计算机程序设计语言,由吉多·范罗苏姆创造,第一版发布于1991年,可以视之为一种改良的 ...

  7. Python定义一个函数

    Python函数:实现某种功能的代码段 定义一个函数需要遵循的规则: 1.使用 def 关键字 函数名和( ),括号内可以有形参 匿名函数使用 lambda 关键字定义 2.任何传入参数和自变量必须放 ...

  8. PHP sqrt() 函数

    实例 返回不同数的平方根: <?phpecho(sqrt(0) . "<br>");echo(sqrt(1) . "<br>"); ...

  9. Android 进度条(ProgressBar)和拖动条(Seekbar)补充“自定义组件”(总结)

    这周结束了,我也码了一周的字,感觉还是很有种脚踏实地的感觉的,有时间就可以看看自己的总结再查漏补缺,一步一个脚印,做出自己最理想的项目. 今天我们讲两点: 1.ProgressBar: 其实前面也稍微 ...

  10. python获取系统内存占用信息的实例方法

    psutil是一个跨平台库(http://code.google.com/p/psutil/),能够轻松实现获取系统运行的进程和系统利用率(包括CPU.内存.磁盘.网络等)信息.它主要应用于系统监控, ...