LinkedList
源码介绍
1.介绍
LinkedList
是List的实现类,底层实现是通过双向链表来实现的,该类可以实现很多的数据结构,比如队列,双端队列,栈等。分析类的接口
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList
继承了AbstractSequentialList
类,该类实现了操作集合元素的添加和按照下标获取元素,这些实现是通过ListIterator
的功能实现的,子类只需要完成对size(),listIterator(int index)
实现。
下面是jdk文档的介绍
此类提供的骨干实现List界面最小化以实现此接口由“连续访问”数据存储备份所需的工作(如链接列表)。 对于随机访问数据(如数组), AbstractList应优先于此类。
这个类是在这个意义上AbstractList类相反,它实现了对列表的列表迭代器顶部的“随机访问”方法(get(int index),set(int index, E element),add(int index, E element)和remove(int index)),而不是周围的其他方法。
为了实现一个列表,程序员只需要扩展这个类,并提供listIterator和size方法的实现。 对于一个不可修改的列表,程序员只需要实现列表迭代器的hasNext,next,hasPrevious,previous和index方法。
对于可修改的列表,程序员应该另外实现list iterator的set方法。 对于可变大小的列表,程序员应该另外实现list iterator的remove和add方法。
根据Collection接口规范中的建议,程序员通常应该提供一个void(无参数)和集合构造函数。
-
实现了
List
接口,该类具有List定义的所有功能,包括迭代,添加等操作,也能对它进行队列操作。 -
实现了
Deque
接口,该接口继承了Queue
接口,除了具有队列的结构特性,也具有双端队列的特性,可以完成元素两段的添加和删除。
小总结: LinkedList
可以完成List的操作,也可以实现队列和双端队列功能。
2.节点元素
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;
}
}
3.构造函数
public LinkedList() {
}
// 创建一个LinkedList,使用Collection中的全部元素。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
4.成员变量
//集合中元素的个数
transient int size = 0;
//第一个节点元素
transient Node<E> first;
//末尾节点元素
transient Node<E> last;
5.添加元素
//尾部添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
public void addLast(E e) {
linkLast(e);
}
//尾部插入节点
void linkLast(E e) {
final Node<E> l = last;//l是尾节点
//创建新节点,节点prev属性是尾节点,next置为null
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;//尾节点后移
if (l == null)//判断集合是否是空元素,如果是的话,然first节点指向这个节点
first = newNode;
else //不是null,则将上一个元素的next元素,指向尾节点
l.next = newNode;
size++;
modCount++;
}
//头部插入元素,队列操作
public void addFirst(E e) {
linkFirst(e);
}
//插入节点,在链表头部,需要判断链表是否null,如果null,则要让last指向新节点
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//存在链表,则让原先的头节点的prev指向新头结点
f.prev = newNode;
size++;
modCount++;
}
//指定下标插入元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)//尾元素,直接插入尾部
linkLast(element);
else //插入到指定元素的前面
linkBefore(element, node(index));
}
//在succ节点元素的前面插入元素,succ是一定存在,但是要判断succ是否是first
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,需要改变first值
first = newNode;
else
pred.next = newNode;//前置节点的next指针,指向新添加节点
size++;
modCount++;
}
//批量添加
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//实现
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//下标检查,保证 0<=index<=size,
/* 和检查根据下标获取元素的校验不同,这个可以等于size
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
*/
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)//c为null,则不需要操作,返回false
return false;
Node<E> pred, succ;
if (index == size) {//如果index等于元素的个数,说明在尾部插入,不存在后置节点
succ = null;
pred = last;
} else {
succ = node(index);//否则,就获取下标位置元素,存在succ中
pred = succ.prev;//
}
for (Object o : a) {
E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)//表示空链表,则要第一次添加c中的元素时,将其置为first
first = newNode;
else
pred.next = newNode;//建立连接,perd.next=新节点
pred = newNode;//指针元素后移
}
//将后续节点接上
if (succ == null) {
last = pred;//不存在后续节点,则让last等于链表的末尾节点
} else {//存在后续节点,则让后续节点的perv=pred,pred.next=succ
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
6.获取元素
链表中不存在索引,要实现list中的通过下标获取元素,则是通过计数法。
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//获取指定下标的元素
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//范围检查代码,是让下标在元素个数之中
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
//获取指定位置的元素
Node<E> node(int index) {
//如果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;
}
}
//查找指定元素
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//顺序查找,遍历链表
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;
}
7.修改
//可知,也是借助node(index),来获取元素,然后修改
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
8.移除
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 remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* Unlinks non-null first 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;
}
/**
* Unlinks non-null last node 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;
}
//前两个移除元素,都是这个特殊情况,只分析这一种,对只有一个元素也应用
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;//last置为上一个元素
} else {
next.prev = prev;//下一个元素的prev指针更新为上一个元素
x.next = null;
}
x.item = null;// help - GC
size--;
modCount++;
return element;
}
9.迭代
//迭代元素,具体我也没看
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
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;
}
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();
}
}
2.对列操作
/**** 用链表完成队列操作 ****/
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}
/***** Queue operations. ****/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E element() {
return getFirst();
}
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E remove() {
return removeFirst();
}
public boolean offer(E e) {
return add(e);
}
/***** Deque operations ****/
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
/***** Stack operations ****/
public void push(E e) {
addFirst(e);
}
public E pop() {
return removeFirst();
}
暂且为止,以后补充。