类关系图
类属性
//列表大小
transient int size = 0;
/**
* 首节点指针
*/
transient Node<E> first;
/**
* 尾节点指针
*/
transient Node<E> last;
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底层是一个双端链表,链表的每个mode既有前驱指针prev,又有后继指针next:
构造函数
/**
* 构造空列表.
*/
public LinkedList() {
}
/**
* 构造一个包含特定集合的列表
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
对链表进行操作的方法
首尾结点的删除添加
双端链表的首位元素添加删除操作。
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; // 后继结点设为空
first = next;//头指针后移
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
/**
* 不连接最后结点l
*/
private E unlinkLast(Node<E> l) {
final E element = l.item;//获取尾节点中的元素
final Node<E> prev = l.prev;//获取尾结点的前驱结点
l.item = null;//元素设为空
l.prev = null; // 尾节点的前驱指针设为空,帮助GC回收
last = prev;//尾节点前移
if (prev == null)//前驱结点为空,则列表为空
first = null;//首节点设为空
else
prev.next = null;//前驱结点不为空,则将前驱结点的后继节点设为空
size--;//列表大小-1
modCount++;
return element;
}
/**
* 在列表首部添加元素
*/
private void linkFirst(E e) {
final Node<E> f = first;//获取当前的首节点
final Node<E> newNode = new Node<>(null, e, f);//新节点的前驱为null,后继为f。
first = newNode;//移动头指针
if (f == null)//如果列表为null
last = newNode;//尾指针指向新节点
else
f.prev = newNode;//不为空时原来的头节点前驱指向新节点
size++;
modCount++;
}
/**
*在列表尾部插入元素
*/
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++;
}
在任意位置添加结点
在链表中的任意位置添加元素。
/**
* 在一个非空结点前添加元素
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;//获取结点succ前驱结点
final Node<E> newNode = new Node<>(pred, e, succ);//新结点的前驱为succ前驱结点,后继为succ
succ.prev = newNode;//succ的前驱为新结点
if (pred == null)//前驱为空
first = newNode;//头指针指向新结点
else
pred.next = newNode;//不为空,前驱的后继结点设为新节点。
size++;
modCount++;
}
删除任意位置的元素
在链表中的任意位置删除元素。
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;//获取前驱结点
//将x的前驱结点设为空
if (prev == null) {//前驱为空
first = next;//头指针指向后继
} else {
prev.next = next;//不为空前驱结点的后继为后继节点
x.prev = null;//结点的pre设为空
}
//将x的后继节点设为空
if (next == null) {//后继为空
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
查找相应位置的结点
返回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;
}
}
公有方法
这里的方法都时通过基本的链表操作完成的。
返回首节点、尾结点
/**
* 返回首节点
*/
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;
}
删除首节点、尾节点
/**
* Removes and returns the first element from this list.
*
* @return the first element from this list
* @throws NoSuchElementException if this list is empty
*/
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 void addFirst(E e) {
linkFirst(e);
}
/**
* 在尾部追加元素
*/
public void addLast(E e) {
linkLast(e);
}
在特定位置插入元素
private boolean isPositionIndex(int index) {//下标是否违法
return index >= 0 && index <= size;// 插入位置可以是尾节点的下个结点
}
private void checkPositionIndex(int index) {//下标位置违法抛出异常
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
public void add(int index, E element) {
checkPositionIndex(index);//检查越界
if (index == size)//index在尾部
linkLast(element);
else//没有在尾部
linkBefore(element, node(index));//插入相应节点的前驱
}
在特定位置插入集合
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//下标是否违法
Object[] a = c.toArray();//集合转数组
int numNew = a.length;
if (numNew == 0)//数组长度为0,添加失败
return false;
Node<E> pred, succ;
if (index == size) {//插入位置为根节点
succ = null;
pred = last;
} else {
succ = node(index);//找到位置为index的结点取出
pred = succ.prev;//找到前驱结点
}
for (Object o : a) {//遍历插入
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);//当前结点的前驱指向pre,后继为null
if (pred == null)//前驱结点为空
first = newNode;//头指针指向该节点
else
pred.next = newNode;//前驱结点的后继结点指向当前节点
pred = newNode;//前驱结点变为当前结点
}
if (succ == null) {//如果succ为空,尾指针指向前驱结点
last = pred;
} else {//否则将succ连接到插入的最后一个结点
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
返回结点下标
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++;//下标+1
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))//元素相等,返回下标
return index;
index++;
}
}
return -1;
}
根据值删除结点
/**
* 移除链表中元素第一次出现的结点
*/
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;
}
删除相应位置的元素
private boolean isElementIndex(int index) {//检查元素下标
return index >= 0 && index < size;//删除位置不能超过尾元素
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
public E remove(int index) {
checkElementIndex(index);//检查位置越界
return unlink(node(index));//删除结点
}
栈操作
用双端链表模拟栈操作。
public E peek() {//获取首元素
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E pop() {//删除首元素
return removeFirst();
}
public void push(E e) {//添加首元素
addFirst(e);
}
队列操作
用双端链表模拟队列。
public E poll() {//取出队首元素
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public boolean offer(E e) {//插入队尾
return add(e);
}
双端队列操作
双端链表特有的操作。
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);
}