Java LinkedList 源码分析及总结
文章目录
1、LinkedList 集合简介
(1)LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列,它是基于双向链表实现的。
(2)LinkedList 实现 List 接口,能对它进行队列操作。
(3)LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
(4)LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
(5)LinkedList 实现Cloneable 表明其可以调用clone()方法来返回实例的field-for-field拷贝
(6)实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
(7)LinkedList不是线程安全的,如果想使LinkedList变成线程安全的,可以调用静态类Collections类中的synchronizedList方法:
List list=Collections.synchronizedList(new LinkedList(…));
2、类的属性
先看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的关键属性
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 实际元素个数
transient int size = 0;
// 头结点
transient Node<E> first;
// 尾结点
transient Node<E> last;
}
LinkedList的属性非常简单,一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。注意,头结点、尾结点都有transient关键字修饰,这也意味着在序列化时该域是不会序列化的。
3、构造方法
(1)无参构造
public LinkedList() {
}
(2)带Collections有参构造
//将集合c中的各个元素构建成LinkedList链表。
public LinkedList(Collection<? extends E> c) {
// 调用无参构造函数
this();
// 添加集合中所有的元素
addAll(c);
}
4、LinkedList 常见方法
4.1 添加方法
(1)add(E e)
/**
* 将元素添加到链表尾部
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 在表尾插入指定元素e
*/
void linkLast(E e) {
final Node<E> l = last;
//新建节点newNode,节点的前指针指向l,后指针为null
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
//如果原来的尾结点为null,更新头指针,否则使原来的尾结点l的后置指针指向新的头结点newNode
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
(2)add(int index, E element)
/**
* 在指定位置添加元素
*/
public void add(int index, E element) {
//检查索引是否处于[0-size]之间
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
()addAll(Collection<? extends E> c)
/**
* 插入指定集合到链尾
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 插入指定集合到链尾的指定位置
*/
public boolean addAll(int index, Collection<? extends E> c) {
//1:检查index范围是否在size之内
checkPositionIndex(index);
//2:toArray()方法把集合的数据存到对象数组中
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//3:得到插入位置的前驱节点和后继节点
Node<E> pred, succ;
//如果插入位置为尾部,前驱节点为last,后继节点为null
if (index == size) {
succ = null;
pred = last;
} else {
//否则,调用node()方法得到后继节点,再得到前驱节点
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;
}
//如果插入位置在尾部,重置last节点
if (succ == null) {
last = pred;
}//否则,将插入的链表与先前链表连接起来
else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
(4)addFirst(E e)
/**
* 在表头插入指定元素.
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 在表头添加指定元素e
*/
private void linkFirst(E e) {
final Node<E> f = first;
//新建节点,节点的前指针指向null,后指针原来的头节点
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
//如果原来的头结点为null,更新尾指针,否则使原来的头结点f的前置指针指向新的头结点newNode
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
4.2 获取方法
(1)get(int index)
/**
* 返回指定索引处的元素
*/
public E get(int index) {
//检查index范围是否在size之内
checkElementIndex(index);
//调用node(index)去找到index对应的node然后返回它的值
return node(index).item;
}
/**
* 返回在指定索引处的非空元素
*/
Node<E> node(int 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;
}
}
关键在于node()方法:
/**
* Returns the (non-null) Node at the specified element index.
*/
//这里查询使用的是先从中间分一半查找
Node<E> node(int index) {
// assert isElementIndex(index);
//"<<":*2的几次方 “>>”:/2的几次方,例如:size<<1:size*2的1次方,
//这个if中就是查询前半部分
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;
}
}
(2)获取头节点(index=0)数据方法
/**
* 返回链表中的头结点的值.
*/
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
/**
* 获取表头节点的值,头节点为空抛出异常
*/
public E element() {
return getFirst();
}
/**
* 返回头节点的元素,如果链表为空则返回null
*/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 返回队列的头元素,如果头节点为空则返回空
*/
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
区别:
getFirst(),element(),peek(),peekFirst() 这四个获取头结点方法的区别在于对链表为空时的处理,是抛出异常还是返回null。
4.3 删除方法
(1)remove(Object o) 删除指定元素
/**
* 正向遍历链表,删除出现的第一个值为指定对象的节点
*/
public boolean remove(Object o) {
//LinkedList允许存放Null
//如果删除对象为null
if (o == null) {
//从头开始遍历
for (Node<E> x = first; x != null; x = x.next) {
//找到元素
if (x.item == null) {
//从链表中移除找到的元素
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
(2)remove() ,removeFirst(),pop(): 删除头节点
/**
* 删除并返回栈头元素
*/
public E pop() {
return removeFirst();
}
/**
* 删除并返回头节点,如果链表为空,抛出异常
*/
public E remove() {
return removeFirst();
}
/**
* 删除并返回表头元素.
*/
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
(3)removeLast(),pollLast(): 删除尾节点
/**
* 删除并返回表尾元素
*/
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
/**
* 删除并返回队列的最后个元素,如果尾节点为空,则返回null.
*/
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
5、分析总结
要点:
(1)linkedList本质上是一个双向链表,通过一个Node内部类实现的这种链表结构
(2)能存储null值
(3)LinkedList最大的好处在于头尾和已知节点的插入和删除时间复杂度都是o(1)。但是涉及到先确定位置再操作的情况,则时间复杂度会变为o(n)。
当然,每个节点都需要保留prev和next指针也是经常被吐槽是浪费了空间。
(4)通过下标获取某个node 的时候,(add select),会根据index处于前半段还是后半段 进行一个折半,以提升查询效率
(5)linkedList不光能当链表,还能当队列使用,这个就是因为实现了Deque接口。
ArrayList和LinkedList的区别
(1)ArrayList是实现了基于动态数组的数据结构,而LinkedList是基于链表的数据结构
(2)对于随机访问的get和set,ArrayList要优于LinkedList,因为LinkedList基于指针的移动
(3)当插入的数据量很小时,两者区别不太大,当插入的数据量大时,大约在容量的1/10之前,LinkedList会优于ArrayList,在其后就劣与ArrayList,且越靠近后面越差。所以个人觉得,一般首选用ArrayList,由于LinkedList可以实现栈、队列以及双端队列等数据结构,所以当特定需要时候,使用LinkedList,当然咯,数据量小的时候,两者差不多,视具体情况去选择使用;当数据量大的时候,如果只需要在靠前的部分插入或删除数据,那也可以选用LinkedList,反之选择ArrayList反而效率更高。