一、继承关系
public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
1. 继承父类关系
1.1 继承AbstractSequentialList类,是一个双向链表;
1.2 实现了List接口,可以对其进行队列操作;
1.3 实现了Cloneable接口,允许克隆;
1.4 实现了Serializable接口,可以对其进行序列化操作;
1.5 实现了Deque接口,能将LinkedList当作双端队列使用。
二、成员变量
//用于记录链表的长度
transient int size = 0;
//链表头结点
transient Node<E> first;
//链表的尾节点
transient Node<E> last;
//Node 是 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;
}
}
三、构造器
3.1 LinkedList()
public LinkedList() {}
声明一个空的链表
3.2 LinkedList(Collection<? extends E> c)
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
声明一个集合c的链表;
首先是调用LinkedList()方法,声明一个空链表,然后在调用addAll(size, c) 方法将集合元素添加至链表中。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
---------------------------------------------
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
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)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
调用checkPositionIndex判断index在当前链表中,集合c转成对象数组,numNew记录插入集合的长度,声明pred和succ两个Node对象,如果插入位置和当前链表长度一致,则说明是在该链表尾部插入集合,即succnull,pred=last;
否则通过 node(index) 方法获取index所在的对象,并将该node对象的prev赋值给pred;
循环遍历对象数组a,将对象转成Node对象,并声明新的Node节点对象,并将pred指向该Nodeprev,当prednull说明当前链表是个空链表,newNode节点指向first节点,如果pred不为空,则将pred的next指向当前节点(pred.next = newNode)
同时将newNode赋值给pred;将集合c元素加入到链表中之后,
如果succ==null,则将pred指向尾节点last,否则当前节点后驱指向插入节点,插入节点的前驱指向pred。
四、成员方法
4.1 linkFirst(E e): 插入头节点
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
f.prev = newNode;
size++;
modCount++;
}
将头结点赋值给f,创建一个新节点newNode,设置前驱为null,后驱指向f;
头结点first指向newNode,如果f为null(说明该链表为空),则尾节点指向newNode,否则f的前驱指向头结点;
链表size加1,操作次数自增;
4.2 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++;
}
声明l指向尾节点last,声明新的节点newNode,并将新节点的前驱指向l,后驱设置为null,
last指向新节点newNode,如果l为null(说明链表为空),头结点指向新节点,否则l后驱指向新节点newNode,链表数据加1,操作次数自增1.
4.3 void linkBefore(E e, Node succ):在succ节点前插入e节点
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++;
}
使用前提节点succ不为null;
声明节点pred指向succ的前驱,创建新节点newNode,使其前驱指向节点succ的前驱,后驱指向succ节点。succ前驱指向新节点newNode,如果pred为空(说明succ节点头结点),则first头结点指向新节点,否则pred的后驱指向新节点;链表长度加1,链表操作次数自增1;
4.4 private E 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;
}
使用前提节点f是头节点且不为null;
内部方法用于删除头结点
element指向节点f的item,节点next指向f.next;
将f的item和next都置为null,GC回收;
头结点指向next节点,如果next为null,则说明是个空链表,尾节点为null。否则next的前驱设置为null,size–,操作次数自增,返回头结点的item对象。
4.5 private E unlinkLast(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;
}
使用前提节点l是尾节点且不为null;
私有方法,用于删除尾节点:
element指向尾节点l的item,用于返回;
节点prev指向尾节点l的前驱,将尾节点l前驱,item设置为null,再将尾节点指向prev,如果prev==null,这说明链表是个空链表,头结点为null,否则prev后驱设置为null,链表长度自减,操作次数自增,返回尾节点的对象。
4.5 E unlink(Node 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;
}
使用该方法前提节点x不能为null;
声明对象element指向节点x的对象,
节点next指向节点x的后驱,节点prev指向节点x的前驱,如果prev为null,则说明x是头结点,即将头结点指向next,否则将x的前驱节点prev的后驱指向x的后驱节点,并将x前驱设置为null;
如果next为null,则说明节点x是尾节点,即将尾节点指向x的前驱prev,否则将x的后驱节点的前驱指向prev,x的后驱置为null;
将节点x的对象置为null,连链表长度自减,修改操作次数自增,并返回该节点的对象。
4.6 public E getFirst():返回list的头结点对象
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
获取头结点的对象,若头结点为null则抛出NoSuchElementException() 异常。
4.7 public E getLast():获取尾节点的对象
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
4.8 public E removeFirst():删除头结点
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
4.9 public E removeLast():删除尾节点
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
4.10 public void addFirst(E e):将元素设置为头结点
public void addFirst(E e) {
linkFirst(e);
}
4.11 public void addLast(E e):将元素设置为尾节点
public void addLast(E e) {
linkLast(e);}
4.12 public boolean contains(Object o) :判断list是否包含对象o
public boolean contains(Object o) {
return indexOf(o) != -1;
}
4.13 public int size() :返回list长度
public int size() {
return size;
}
4.14 public boolean add(E e):在list尾部添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
4.15 public boolean remove(Object o):删除list中的元素 o
public boolean remove(Object o) {
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;
}
如果元素o为null,则遍历list,满足元素为null时,调用unlink方法移除o,并返回true;
否则在遍历list用equals比较是否相等。
4.16 addAll(Collection<? extends E> c) : 将集合元素添加到list中
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
4.17 addAll(int index, Collection<? extends E> c):在下标index后面将集合元素添加至list
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
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)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
首先判断下标是否在list内;
将集合转成对象数组a,numNew记录a的长度,如果集合为空,则返回false;
声明两个节点prev和succ,如何下标index等于当前list长度,则说明是在list尾部添加元素,节点pred指向尾节点,succ为null,否则succ指向index下标的节点,pred指向succ的前驱节点;
遍历对象数组a,创建新节点newNode,如果prev为空,则说明prev为头结点,即头结点指向新节点,否则pred的后驱节点指向新节点,同时将pred指向新节点;
如果节点succ为null,则尾节点指向pred,否将pred和succ节点的前驱和后驱相互指向,使其连接;
list长度增加numNew,操作次数自增,返回true.
4.18 public void clear():清除list元素
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable
Iterator for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
使用迭代器遍历list节点元素,所有节点设为null,长度设置为0,修改次数自增。
4.19 public E get(int index) :获取下标下的对象
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
校验下标是否在list区间内,通过node获取某下标节点,并返回其item。
4.20 public E set(int index, E element) :设置某下标元素,并返回旧元素
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
4.21 public void add(int index, E element):在下标index处插入新元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
4.22 public E remove(int index):删除某下标处元素
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
4.23 Node node(int index) :获取某下标处节点
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;
}
}
使用该方法前提是index在list区间内,遍历时,采用一次二分遍历。
4.24 public int indexOf(Object o):获取对象o第一次在list出现的下标
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;
}
找到返回下标,未找到返回-1,判断对象是否相等分null和非null。
4.25 public int lastIndexOf(Object o) :获取对象o最后一次在list出现的下标
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;
}
逻辑基本与4.24一致,不过遍历是从后往前查询。
4.26 public E peek():获取第一个元素(可以为null)
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
4.27 public E element() :获取第一个元素(不能为null)
public E element() {
return getFirst();
}
4.28 public E poll() :获取第一个元素并删除(可以为null)
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
4.29 E remove() :删除第一个元素(不能为null)
public E remove() {
return removeFirst();
}
4.30 public boolean offer(E e):在list尾部添加元素
public boolean offer(E e) {
return add(e);
}
4.31 public boolean offerFirst(E e):元素放置在头节点
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
4.32 public boolean offerLast(E e):元素放置在尾节点
public boolean offerLast(E e) {
addLast(e);
return true;
}
4.33 public E peekFirst():获取第一个元素(可以为null)
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
4.34 public E peekLast() ::获取最后一个元素(可以为null)
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
4.35 public E pollFirst():弹出第一个元素并将其移除(可以为null)
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
4.36 public E pollLast() :弹出最后一个元素并将其移除(可以为null)
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
4.37 public void push(E e) :添加到头节点
public void push(E e) {
addFirst(e);
}
4.38 public E pop() :移除头节点(不能为null)
public E pop() {
return removeFirst();
}
4.39 public boolean removeFirstOccurrence(Object o) :移除某元素(第一次出现的位置)
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
4.40 public boolean removeLastOccurrence(Object o):移除元素在list最后出现的位置
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
五、内部类
private static class Node
private class ListItr implements ListIterator
static final class LLSpliterator implements Spliterator
private class DescendingIterator implements Iterator
暂不解析,具体看其源码