我们直接从源码来分析LinkedList的结构:

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

LinkedList是List和Deque接口的双向链表的实现。实现了所有可选列表操作,并允许包括null值
LinkedList既然是通过双向链表去实现的,那么它可以被当作堆栈、队列或双端队列进行操作。并且其顺序访问非常高效,而随机访问效率比较低。

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

LinkedList涉及的一些操作链表的变量:

transient int size = 0; //链表中元素的个数

transient Node<E> first; //指向链表的头节点

transient Node<E> last; //指向链表尾节点
transient 关键字修饰变量表示该值不参与序列化

LinkedList构造函数:

第二种构造函数过程比较复杂,这里重点讲解

1.调用默认构造函数

2.调用addAll(c)方法,最终调用的是addAll(size, c)方法

  (1)该方法先进行index越界判断,由于index = size所以没有越界

  (2)将集合c转换成Object数组,判断数组长度是否为0,为0返回false

  (3) 设置Node<E> pred, succ指针辅助链表操作

    由于index == size,所以设置succ = null, pred = last,相当于从链表尾进行插入操作

  (4)遍历Object数组,根据数组每个元素生成一个Node节点,并且修改指针将节点插入链表

  下面假设Object有3个元素,具体展示下3个节点的插入过程:

   初始Node<E> pred, succ; 两个指针为空,且first,last也为空
  然后执行:
    if (index == size) { //当我们插入位置为链表节点的最后位置时
succ = null;
pred = last;
  }

  接着执行:

   for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null) //pred为空,说明该链表为空,所以设置newNode为第一个节点
first = newNode; // first指向第一个节点
else
pred.next = newNode;
pred = newNode;
}
    if (succ == null) {
last = pred;
}
 

下面是具体的源码:

 public LinkedList() { //默认构造函数
}
public LinkedList(Collection<? extends E> c) { //传入集合参数的构造函数
this(); //调用默认构造函数
addAll(c); //方法见下面
}
public boolean addAll(Collection<? extends E> c) { //回调addAll(size, c) 是重载方法
return addAll(size, c); //size值为当前节点个数
}
public boolean addAll(int index, Collection<? extends E> c) { //该方法实现再链表index位置插入集合中的所有元素
checkPositionIndex(index); //检查index是否越界 Object[] a = c.toArray();  //将集合c转换成Object数组
int numNew = a.length;  //数组长度
if (numNew == 0)  //判断数组长度,为0直接返回false
return false;
    //下面将构建链表
Node<E> pred, succ;   //辅助指针
if (index == size) { //当我们插入位置为链表节点的最后位置时
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
} for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null) //pred为空,说明该链表为空,所以设置newNode为第一个节点
first = newNode; // first指向第一个节点
else
pred.next = newNode;
pred = newNode;
} if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
} size += numNew; //元素个数增加
modCount++;  //链表修改次数加一
return true;
}
private void checkPositionIndex(int index) { //检查index是否越界
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
 private boolean isPositionIndex(int index) { //判断index值
return index >= 0 && index <= size;
}
public boolean addAll(int index, Collection<? extends E> c)方法还有一种情况,是在index下插入元素,该index != size
我们还是从源码分析:
这里执行else操作, succ = node(index)具体解析在源码注释中体现
具体的节点插入就不再多讲,大家画过图能分析清楚的。
   Node<E> pred, succ;   //辅助指针
if (index == size) { //当我们插入位置为链表节点的最后位置时
succ = null;
pred = last;
} else {
succ = node(index); //succ指向index节点的后一个位置
pred = succ.prev; //pred执行index节点位置
} Node<E> node(int index) {
// assert isElementIndex(index); if (index < (size >> 1)) { //判断index是否小于size/2,如果小于从前往后查找,如果大于从后往前查找
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;
}
}

 Deque双端链表操作:

  插入:

 public void addFirst(E e) { //将指定元素插入此列表的开头
linkFirst(e);
}
private void linkFirst(E e) { //插入列表开头的具体方法
final Node<E> f = first; //定义一个f指向first队头指针
final Node<E> newNode = new Node<>(null, e, f); //新建一个newNode,该Node下一个指针指向f(即原列表头位置)
first = newNode; //fisrt指向newNode节点,也就是指向现在的列表第一个节点
if (f == null) //如果原链表尾空
last = newNode; //原链表last也必须指向newNode
else //链表不为空
f.prev = newNode; //设置原链表头节点的prev 指向newNode
size++; //链表元素个数加一
modCount++; //链表修改次数加一
}
public void addLast(E e) { //将指定元素添加到此列表的结尾
linkLast(e);
}
void linkLast(E e) {
final Node<E> l = last; //定义一个l指向链表最后一个节点位置即last指向的位置
final Node<E> newNode = new Node<>(l, e, null);//新建一个newNode,该Node的prev执行原链表的最后一个节点
last = newNode;//原链表的last指针指向newNode
if (l == null) //如果原链表为空,设置原链表头节点指向newNode
first = newNode;
else //如果原链表不为空,设置原链表最后一个节点的next指向newNode
l.next = newNode;
size++;
modCount++;
}
public boolean offerFirst(E e) { //在此列表的开头插入指定的元素
addFirst(e);
return true;
}
public boolean offerLast(E e) { //在此列表末尾插入指定的元素
addLast(e);
return true;
}

  删除:

  public E removeFirst() { //移除并返回此列表的第一个元素
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f); //删除头节点
}
public E removeLast() { //移除并返回此列表的最后一个元素
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item; //设置一个Element存储要删除节点的值,作为返回值
final Node<E> next = f.next;// 定义一个next指向第二个节点
f.item = null; //将头节点值设置为空
f.next = null; // help GC 断开与头节点的next指针
first = next; //将头指针指向next节点的位置
if (next == null) //如果原链表只有一个元素,删除后,需要将last指向null
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
   private E unlinkLast(Node<E> l) { //删除链尾元素
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null) //当删除该元素后链表为空,头指针设置为空
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}

栈操作:

 public void push(E e) { //入栈,操作列表头
addFirst(e);
}
public E pop() { //出栈
return removeFirst();
}
public E peek() { //获取头节点元素
final Node<E> f = first;
return (f == null) ? null : f.item;
}

队列:

  public boolean offer(E e) { //队尾入队
return add(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;
else
l.next = newNode;
size++;
modCount++;
}
public E poll() { //队头出队
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) { //删除列表头元素
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
public E peek() { //查看队头元素
final Node<E> f = first;
return (f == null) ? null : f.item;
}

LinkedList总体介绍都这里了,都是居于链表操作,其他的一些方法大家可以结合源码分析下。

  

 

Java容器源码解析之——LinkedList的更多相关文章

  1. Java容器源码解析之——ArrayList

    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess ...

  2. Java 容器源码分析之 LinkedList

    概览 同 ArrayList 一样,LinkedList 也是对 List 接口的一种具体实现.不同的是,ArrayList 是基于数组来实现的,而 LinkedList 是基于双向链表实现的.Lin ...

  3. Java集合类源码解析:Vector

    [学习笔记]转载 Java集合类源码解析:Vector   引言 之前的文章我们学习了一个集合类 ArrayList,今天讲它的一个兄弟 Vector.为什么说是它兄弟呢?因为从容器的构造来说,Vec ...

  4. 【转】Java HashMap 源码解析(好文章)

    ­ .fluid-width-video-wrapper { width: 100%; position: relative; padding: 0; } .fluid-width-video-wra ...

  5. Java——LinkedHashMap源码解析

    以下针对JDK 1.8版本中的LinkedHashMap进行分析. 对于HashMap的源码解析,可阅读Java--HashMap源码解析 概述   哈希表和链表基于Map接口的实现,其具有可预测的迭 ...

  6. Java泛型底层源码解析-ArrayList,LinkedList,HashSet和HashMap

    声明:以下源代码使用的都是基于JDK1.8_112版本 1. ArrayList源码解析 <1. 集合中存放的依然是对象的引用而不是对象本身,且无法放置原生数据类型,我们需要使用原生数据类型的包 ...

  7. Java集合类源码解析:ArrayList

    目录 前言 源码解析 基本成员变量 添加元素 查询元素 修改元素 删除元素 为什么用 "transient" 修饰数组变量 总结 前言 今天学习一个Java集合类使用最多的类 Ar ...

  8. Java 容器源码分析之Map-Set-List

    HashMap 的实现原理 HashMap 概述 HashMap 是基于哈希表的 Map 接口的非同步实现.此实现提供所有可选的映射操作,并允许使用 null 值和 null 键.此类不保证映射的顺序 ...

  9. Java集合类源码解析:LinkedHashMap

    前言 今天继续学习关于Map家族的另一个类 LinkedHashMap .先说明一下,LinkedHashMap 是继承于 HashMap 的,所以本文只针对 LinkedHashMap 的特性学习, ...

随机推荐

  1. HDU 4856 Tunnels(BFS+状压DP)

    HDU 4856 Tunnels 题目链接 题意:给定一些管道.然后管道之间走是不用时间的,陆地上有障碍.陆地上走一步花费时间1,求遍历全部管道须要的最短时间.每一个管道仅仅能走一次 思路:先BFS预 ...

  2. Android实现天气预报温度/气温折线趋势图

     Android实现天气预报温度/气温折线趋势图 天气预报的APP应用中,难免会遇到绘制天气温度/气温,等关于数据趋势的折线或者曲线图,这类关于气温/温度的折线图,通常会有两条线.一条是高温线,一 ...

  3. iOS CoreData介绍和使用(以及一些注意事项)

    iOS CoreData介绍和使用(以及一些注意事项) 最近花了一点时间整理了一下CoreData,对于经常使用SQLite的我来说,用这个真的有点用不惯,个人觉得实在是没发现什么亮点,不喜勿喷啊.不 ...

  4. windows模式编译

    //预编译,linker链接,Windows模式#pragma comment(linker,"/subsystem:\"windows\" /entry:\" ...

  5. ios问题bug收录——1

     **[2713:59682] *** Assertion failure in -[MBProgressHUD show:], /Users/lu/Desktop/****/Pods/MBProgr ...

  6. CSS弹性盒模型flex概念

    盒模型分为:标准w3c盒模型.IE盒模型.以及css中的伸缩盒模型. 先说CSS的伸缩盒模型:flex模型是CSS3引入的新的布局模型,是flexible box的缩写,一般称之为弹性盒模型.和CSS ...

  7. 【原创】不重启was server重新加载应用class文件

    类装入和更新检测(Class loading and update detection settings)菜单路径:Applications < Application Types < W ...

  8. activity(工作流)初步学习记录

    1.概念 工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档.信息或任务的过程自动进行,从而实现某个预期 ...

  9. FCC编程题之中级算法篇(下)

    介绍 本篇是"FCC编程题之中级算法篇"系列的最后一篇 这期完结后,下期开始写高级算法,每篇一题 目录 1. Smallest Common Multiple 2. Finders ...

  10. RegExp javascript正则表达式 :

    传统的查找字符串中的相关的字符 :<script type="text/javascript">var str='aaa23uihjkikh666jhjhk888kuh ...