java集合类之LinkedList详解
一、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++;}
说明:
- 创建newNode节点,将newNode的后继指针指向succ,前驱指针指向pred
- 将succ的前驱指针指向newNode
- 根据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详解的更多相关文章
- 【Java集合】LinkedList详解前篇
[Java集合]LinkedList详解前篇 一.背景 最近在看一本<Redis深度历险>的书籍,书中第二节讲了Redis的5种数据结构,其中看到redis的list结构时,作者提到red ...
- java集合类之ArrayList详解
一.ArrayList源码分析 1.全局变量 (1)默认容量(主要是通过无参构造函数创建ArrayList时第一次add执行扩容操作时指定的elementData的数组容量为10) private s ...
- 【Java集合类】ArrayList详解 (JDK7)
相信对于使用过Java的人来说,ArrayList这个类大家一定不会陌生. 数据结构课上讲过, Array是数组,它能根据下标直接找到相应的地址,所以索引速度很快,但是唯一的缺点是不能动态改变数组的长 ...
- 【Java集合】LinkedList详解中篇
这是关于LinkedList的第二篇文章,我将会源码分析LinkedList的部分重要代码,关键地方我都有注释说明,希望大家能比较明白的看懂! 分析源码按照顺序分析: 变量 构造方法 方法 一.变量 ...
- Java 8 Stream API详解--转
原文地址:http://blog.csdn.net/chszs/article/details/47038607 Java 8 Stream API详解 一.Stream API介绍 Java8引入了 ...
- Java基础学习总结(24)——Java单元测试之JUnit4详解
Java单元测试之JUnit4详解 与JUnit3不同,JUnit4通过注解的方式来识别测试方法.目前支持的主要注解有: @BeforeClass 全局只会执行一次,而且是第一个运行 @Before ...
- LinkedList详解-源码分析
LinkedList详解-源码分析 LinkedList是List接口的第二个具体的实现类,第一个是ArrayList,前面一篇文章已经总结过了,下面我们来结合源码,学习LinkedList. 基于双 ...
- java反射机制深入详解
java反射机制深入详解 转自:http://www.cnblogs.com/hxsyl/archive/2013/03/23/2977593.html 一.概念 反射就是把Java的各种成分映射成 ...
- 国际化,java.util.ResourceBundle使用详解
java.util.ResourceBundle使用详解 一.认识国际化资源文件 这个类提供软件国际化的捷径.通过此类,可以使您所编写的程序可以: 轻松地本地化或翻译成不同的 ...
随机推荐
- Java并发包下的几个API
并发包 (计数器)CountDownLatch (屏障)CyclicBarrier (计数信号量)Semaphore 案例: 需求: 代码: 并发包 (计数器)CountDownLatch Coun ...
- Java静态代码块、代码块及构造函数执行顺序
根据以下程序进行分析 定义一个父类 package sas.LearnJava; public class ExcuteOrderTest { { System.out.println("我 ...
- lambda表达式不同对象根据对象某个属性去重
1.有时候有两个list对象,我们想要去重,比如: List<User> userList和List<Person>personList 想通过User的id和Person的i ...
- jumper-server-第一次粗略配置
https://www.cnblogs.com/zsl-find/articles/11179450.html
- yum rpm apt-get wget 辨析
1)wget: 类似于迅雷,是一种下载工具,通过HTTP.HTTPS.FTP三个最常见的TCP/IP协议下载,并可以使用HTTP代理名字是World Wide Web”与“get”的结合.类似于cur ...
- eclipse wifi 连接手机
参考:http://blog.csdn.net/onlyonecoder/article/details/9121397 首先打开手机的wifi设置,使其连接到网络.然后,需要在手机上对adb连接端口 ...
- 实战spring自定义属性(schema)
关于spring自定义属性(schema) 在开发Dubbo应用的时候,我们会在xml中做以下类似的配置: <dubbo:application name="dubbo_service ...
- 数据库高级:SQL-CREATE-TABLE语句
作者:松软科技(www.sysoft.net.cn) 发布时间:2019/3/17 9:34:51 CREATE TABLE 语句 CREATE TABLE 语句用于创建数据库中的表. SQL CRE ...
- 制作简易的3D相册
今天介绍一下3D相册,用到了开源的FeatureCoverFlow控件,之前的几个作品用的也全都是开源的控件,为什么要用开源的控件呢,因为...他稳定啊! 1.准备 仍然是,去掉标题栏,然后导 ...
- centos下nc的安装和使用
安装:yum install nc.x86_64 发送文件: nc -l port < somefile.xxx 接收文件: nc -n x.x.x.x port > somefile.x ...