一、LinkedList简介

由于LinkedList是一个实现了Deque的双端队列,所以LinkedList既可以当做Queue,又可以当做Stack,在将LinkedList当做Stack时,使用pop()、push()、peek()方法需要注意的是LinkedList内部是将链表头部当做栈顶,链表尾部当做栈底

LinkedList是一个双向链表,没有初始化大小,也没有扩容机制,就是一直在前面或者后面新增就好

特点:随机访问慢、插入删除速度快

二、源码分析

由于LinkedList实现了List和Deque两个接口,所以LinkedList方法分两种,一种是List接口的方法,第二种是Deque接口的方法

1、全局变量

(1)当前链表中的数据个数

 transient int size = 0;

(2)指向链表头部

 transient Node<E> first;

(3)指向链表尾部

 transient Node<E> last;

2、构造函数

(1)不带参数的构造方法

 public LinkedList() {
}

(2)带collection参数的构造方法

 public LinkedList(Collection<? extends E> c) {
this();
addAll(c);//
}

说明:当使用第二个构造方法时,会调用addAll()方法将集合中的元素添加到链表中

3、方法

(1)LinkLast(E 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++;
}

说明:LinkLast方法就是一个链表尾部添加一个双端节点的操作,但是需要注意对链表为空时头节点的处理

(2) node(ine index)(根据索引index返回node节点)

 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)linkBefore(E e, Node< E > succ)

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

(4)linkFirst(E e)

 private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);//新建节点,以头节点为后继节点
first = newNode;
//如果链表为空,last节点也指向该节点
if (f == null)
last = newNode;
//否则,将头节点的前驱指针指向新节点
else
f.prev = newNode;
size++;
modCount++;}

说明

  1. 创建newNode节点,将newNode的后继指针指向succ,前驱指针指向pred
  2. 将succ的前驱指针指向newNode
  3. 根据pred是否为null,进行不同操作。
    • 如果pred为null,说明该节点插入在头节点之前,要重置first头节点
    • 如果pred不为null,那么直接将pred的后继指针指向newNode即可

(5)unlink(Node< E > x)

 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;//得到前驱节点
//删除前驱指针
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;
}

(6)unlinkFirst(Node 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;
}

(7)unlinkLast(Node< E > 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;
}

(1)List接口的添加操作

add(E e)用于将元素添加到链表尾部

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

add(int index,E e)用于在指定位置添加元素

 public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}

说明:1、检查index的范围,否则抛出异常 2、如果插入位置是链表尾部,那么调用LindLast方法 3、如果插入位置是链表中间,那么调用linkBefore方法

addAll有两个方法,一个参数的方法表示将集合元素添加到链表尾部;而两个参数的方法指定了开始插入的位置。

 //将集合插入到链表尾部,即开始索引位置为size
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
} //将集合从指定位置开始插入
public boolean addAll(int index, Collection< ? extends E> c) {
//Step 1:检查index范围
checkPositionIndex(index);
//Step 2:得到集合的数据
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//Step 3:得到插入位置的前驱节点和后继节点
Node<E> pred, succ;
//如果插入位置为尾部,前驱节点为last,后继节点为null
if (index == size) {
succ = null;
pred = last;
}
//否则,调用node()方法得到后继节点,再得到前驱节点
else {
succ = node(index);
pred = succ.prev;
}
//Step 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;
}
//如果插入位置在尾部,重置last节点
if (succ == null) {
last = pred;
}
//否则,将插入的链表与先前链表连接起来
else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;}

说明:1. 检查index索引范围

2. 得到集合数据

3. 得到插入位置的前驱和后继节点

4. 遍历数据,将数据插入到指定位置

(2)Deque接口的添加操作

push(E e)

    public void push(E e) {
addFirst(e);
}

说明:push(E e)方法用于将元素添加到链表头部

addFirst(E e)

 public void addFirst(E e) {
linkFirst(e);}

说明:addFirst(E e)方法用于将元素添加到链表头部

addLast(E e)

 public void addLast(E e) {
linkLast(e);}

说明:addLast()方法用于将元素添加到链表尾部,与add方法实现一样,只不过return有区别

offer(E e)

 public boolean offer(E e) {
return add(e);}

说明:此方法用于将数据添加到链表尾部,其内部调用了add(E e)方法

offerFirst(E e)

 public boolean offerFirst(E e) {
addFirst(e);
return true;}

说明:此方法用于将数据插入链表头部,与addFirst区别在于该方法返回特定的返回值,而addFirst返回值为void

offerLast(E e)

 public boolean offerLast(E e) {
addLast(e);
return true;}

说明:offerLast()与addLast()的区别和offerFirst()和addFirst()的区别一样

(3)根据位置取数据

获取任意位置的get(int index)方法

 public E get(int index) {
//检查边界
checkElementIndex(index);
return node(index).item;}

说明:get(int index)方法根据指定索引返回数据,如果索引越界,那么会抛出异常

获取位置为0的头节点数据

LinkedList中有多种方法可以获得头节点的数据,实现大同小异,区别在于对链表为空时的处理,是抛出异常还是返回null

其中getFirst()和element()方法将会在链表为空时,抛出异常:

 public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
} public E element() {
return getFirst();
}

peek()和peekFirst()在链表为空时,返回null

获取位置为size-1的尾节点数据

getLast()方法在链表为空时,会抛出异常

 public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}

peekLast()方法在链表为空时,返回null

  public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}

(4)根据对象获得索引(一旦匹配,立即返回索引)

indexOf(Object o)

 //返回第一个匹配的索引
public int indexOf(Object o) {
int index = 0;
if (o == null) {
//从头往后遍历
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
//从头往后遍历
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}

lastIndexOf(Object o)

 //返回最后一个匹配的索引
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
//从后向前遍历
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
//从后向前遍历
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}

(5)检查链表是否包含对象

contains(Object o)

 public boolean contains(Object o) {
return indexOf(o) != -1;
}

说明:contains(Object o)方法检查对象o是否存在于链表中,此方法调用了IndexOf方法,只要返回结果不是-1,那就说明该对象存在于链表中

(6)删除指定对象

remove(Object o)

 public boolean remove(Object o) {
//如果删除对象为null
if (o == null) {
//从前向后遍历
for (Node<E> x = first; x != null; x = x.next) {
//一旦匹配,调用unlink()方法和返回true
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
//从前向后遍历
for (Node<E> x = first; x != null; x = x.next) {
//一旦匹配,调用unlink()方法和返回true
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}

说明:当删除指定对象时,只需调用remove(Object o)即可,不过该方法一次只会删除一个匹配的对象,如果删除了匹配对象,返回true,否则false。

(7)按照位置删除对象

删除任意指定位置的对象

 public E remove(int index) {
//检查index范围
checkElementIndex(index);
//将节点删除
return unlink(node(index));
}

删除头节点的对象

remove()、removeFirst()、pop()在链表为空时将抛出NoSuchElementException

 public E remove() {
return removeFirst();
} public E pop() {
return removeFirst();
} public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

poll()、pollFirst()在链表为空时返回null

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

(8)删除尾节点的元素

removeLast()在链表为空将抛出NoSuchElementException

 public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}

pollLast()方法在链表为空的时候,返回null

 public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}

(9)迭代器操作

iterator()、listIterator()、listIterator(int index)

 public Iterator<E> iterator() {
return listIterator();
} public ListIterator<E> listIterator() {
return listIterator(0);
} public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}

4、内部类

(1)Node< E >

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

说明:从Node的定义可以看出链表是一个双端链表的结构

(2)ListItr

   private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;//保存当前modCount,确保fail-fast机制
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);//得到当前索引指向的next节点
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
//获取下一个节点
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
//获取前一个节点,将next节点向前移
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

三、Deque接口说明

Deque是Queue的子接口,我们知道Queue是一种队列形式,而Deque则是双向队列,它支持从两个端点方向检索和插入、删除元素

方法

当Deque当做队列使用时(先进先出FIFO),添加元素是添加到队尾,删除时删除的是头部元素,其中的方法有:

队列方法 Deque方法
add(e) addLast(e)
offer(e) offerLast(e)
remove() removeFirst()
poll() pollFirst()
element() getFirst()
peek() peekFirst()

Deque也能当栈用(后进先出)。这时入栈、出栈元素都是在双端队列的头部进行,其中的方法有:

栈方法 Deque方法
push(e) addFirst(e)
oop() removeFirst()
peek() peekFirst()

方法详解:

void addFirst(E e);

将对象e插入到双端队列头部,容间不足时,抛出IllegalStateException异常;

void addLast(E e);

将对象e插入到双端队列尾部,容间不足时,抛出IllegalStateException异常;

boolean offerFirst(E e);

将对象e插入到双端队列头部

boolean offerLast(E e);

将对象e插入到双端队列尾部;

E removeFirst();

获取并移除队列第一个元素,队列为空,抛出NoSuchElementException异常;

E removeLast();

获取并移除队列最后一个元素,队列为空,抛出NoSuchElementException异常;

E pollFirst();

获取并移除队列第一个元素,队列为空,返回null;

E pollLast();

获取并移除队列最后一个元素,队列为空,返回null;

E getFirst();

获取队列第一个元素,但不移除,队列为空,抛出NoSuchElementException异常;

E getLast();

获取队列最后一个元素,但不移除,队列为空,抛出NoSuchElementException异常;

E peekFirst();

获取队列第一个元素,队列为空,返回null;

E peekLast();

获取队列最后一个元素,队列为空,返回null;

boolean removeFirstOccurrence(Object o);

移除第一个满足 (onull ? enull : o.equals(e)) 的元素

boolean removeLastOccurrence(Object o);

移除最后一个满足 (onull ? enull : o.equals(e)) 的元素

void push(E e);

将对象e插入到双端队列头部;

E pop();

移除并返回双端队列的第一个元素

Iterator descendingIterator();

双端队列尾部到头部的一个迭代器;

实现场景

Deque的实现类主要分为两种场景

一般场景:

  • LinkedList大小可变的链表双端队列,允许元素为null
  • ArrayDeque大小可变的数组双端队列,不允许null

并发场景

  • LinkedBlockingDeque 如果队列为空时,获取操作将会阻塞,知道有元素添加

java集合类之LinkedList详解的更多相关文章

  1. 【Java集合】LinkedList详解前篇

    [Java集合]LinkedList详解前篇 一.背景 最近在看一本<Redis深度历险>的书籍,书中第二节讲了Redis的5种数据结构,其中看到redis的list结构时,作者提到red ...

  2. java集合类之ArrayList详解

    一.ArrayList源码分析 1.全局变量 (1)默认容量(主要是通过无参构造函数创建ArrayList时第一次add执行扩容操作时指定的elementData的数组容量为10) private s ...

  3. 【Java集合类】ArrayList详解 (JDK7)

    相信对于使用过Java的人来说,ArrayList这个类大家一定不会陌生. 数据结构课上讲过, Array是数组,它能根据下标直接找到相应的地址,所以索引速度很快,但是唯一的缺点是不能动态改变数组的长 ...

  4. 【Java集合】LinkedList详解中篇

    这是关于LinkedList的第二篇文章,我将会源码分析LinkedList的部分重要代码,关键地方我都有注释说明,希望大家能比较明白的看懂! 分析源码按照顺序分析: 变量 构造方法 方法 一.变量 ...

  5. Java 8 Stream API详解--转

    原文地址:http://blog.csdn.net/chszs/article/details/47038607 Java 8 Stream API详解 一.Stream API介绍 Java8引入了 ...

  6. Java基础学习总结(24)——Java单元测试之JUnit4详解

    Java单元测试之JUnit4详解 与JUnit3不同,JUnit4通过注解的方式来识别测试方法.目前支持的主要注解有: @BeforeClass 全局只会执行一次,而且是第一个运行 @Before  ...

  7. LinkedList详解-源码分析

    LinkedList详解-源码分析 LinkedList是List接口的第二个具体的实现类,第一个是ArrayList,前面一篇文章已经总结过了,下面我们来结合源码,学习LinkedList. 基于双 ...

  8. java反射机制深入详解

    java反射机制深入详解  转自:http://www.cnblogs.com/hxsyl/archive/2013/03/23/2977593.html 一.概念 反射就是把Java的各种成分映射成 ...

  9. 国际化,java.util.ResourceBundle使用详解

    java.util.ResourceBundle使用详解   一.认识国际化资源文件   这个类提供软件国际化的捷径.通过此类,可以使您所编写的程序可以:          轻松地本地化或翻译成不同的 ...

随机推荐

  1. Java并发包下的几个API

    并发包 (计数器)CountDownLatch (屏障)CyclicBarrier (计数信号量)Semaphore 案例: 需求: 代码: 并发包 (计数器)CountDownLatch ​Coun ...

  2. Java静态代码块、代码块及构造函数执行顺序

    根据以下程序进行分析 定义一个父类 package sas.LearnJava; public class ExcuteOrderTest { { System.out.println("我 ...

  3. lambda表达式不同对象根据对象某个属性去重

    1.有时候有两个list对象,我们想要去重,比如: List<User> userList和List<Person>personList 想通过User的id和Person的i ...

  4. jumper-server-第一次粗略配置

    https://www.cnblogs.com/zsl-find/articles/11179450.html

  5. yum rpm apt-get wget 辨析

    1)wget: 类似于迅雷,是一种下载工具,通过HTTP.HTTPS.FTP三个最常见的TCP/IP协议下载,并可以使用HTTP代理名字是World Wide Web”与“get”的结合.类似于cur ...

  6. eclipse wifi 连接手机

    参考:http://blog.csdn.net/onlyonecoder/article/details/9121397 首先打开手机的wifi设置,使其连接到网络.然后,需要在手机上对adb连接端口 ...

  7. 实战spring自定义属性(schema)

    关于spring自定义属性(schema) 在开发Dubbo应用的时候,我们会在xml中做以下类似的配置: <dubbo:application name="dubbo_service ...

  8. 数据库高级:SQL-CREATE-TABLE语句

    作者:松软科技(www.sysoft.net.cn) 发布时间:2019/3/17 9:34:51 CREATE TABLE 语句 CREATE TABLE 语句用于创建数据库中的表. SQL CRE ...

  9. 制作简易的3D相册

      今天介绍一下3D相册,用到了开源的FeatureCoverFlow控件,之前的几个作品用的也全都是开源的控件,为什么要用开源的控件呢,因为...他稳定啊! 1.准备   仍然是,去掉标题栏,然后导 ...

  10. centos下nc的安装和使用

    安装:yum install nc.x86_64 发送文件: nc -l port < somefile.xxx 接收文件: nc -n x.x.x.x port > somefile.x ...