一、类继承关系
二、接口说明
1、Queue接口
Queue接口继承自Collection接口，表示一个先进先出队列，所有的新元素都插入到队尾，从队首获取元素。Queue接口有6个核心方法，两两成对，add和offer表示添加元素到队尾，remove和poll是移除并返回队首的元素，element和peek方法时返回队首的元素但不移除，前者操作失败时如队列已满添加失败或者队列为空移除获取队首元素失败会抛出异常，后者不会，会返回null或者false。正是因为Queue接口返回null表示队列为空所以不允许插入null的元素，即使实现类支持插入null元素。增加的方法如下：
测试用例如下：
@Test
public void test() throws Exception {
Queue<String> queue=new LinkedList<>();
queue.add("test");
queue.add("test2");
queue.add("test3");
queue.add("test4");
queue.add("test5");
//offer添加失败，比如固定长度队列下队列已满，会抛出异常
queue.offer("test6");
queue.offer("test7");
queue.offer("test8");
queue.offer("test9");
queue.offer("test10");
int size=queue.size();
System.out.println(size);
for(int i=0;i<size+1;i++){
//element()和peek()方法都是返回队列头部的元素，队列为空时peek返回null，element()会抛出异常NoSuchElementException
System.out.println("peek:"+queue.peek());
// System.out.println("element:"+queue.element());
//poll()和remove()都是移除并返回头部的元素，队列为空时poll()返回null，remove()抛出异常NoSuchElementException
// System.out.println("poll:"+queue.poll());
System.out.println("remove:"+queue.remove());
}
}2、Deque接口
Deque接口表示一个双端队列，即同时支持在队列的两端执行元素插入或者删除操作，可以当做是先进先出FIFO队列Queue使用，也可以当做后进先出LIFO队列Stack使用。同Queue，操作队列两端元素的方法都有两种形式，一种是操作失败抛出异常，一种是返回null或者false，且都不支持插入null元素。其增加的方法如下：
各方法的关系如下：
测试用例如下：
@Test
public void test2() throws Exception {
Deque<String> deque=new LinkedList<>();
//add()同addLast()是等价的
deque.add("test");
deque.add("test2");
deque.add("test3");
deque.addLast("test4");
deque.addLast("test5");
//offer()和offerLast()是等价的
deque.offer("test6");
deque.offer("test7");
deque.offerLast("test8");
deque.offerLast("test9");
deque.offerLast("test10");
int size=deque.size();
System.out.println(size);
for(int i=0;i<size+1;i++){
//peek()和peekFirst()是等价的
System.out.println("peek:"+deque.peek());
System.out.println("peekFirst："+deque.peekFirst());
//element()和getFirst()是等价的
System.out.println("element："+deque.element());
System.out.println("getFirst："+deque.getFirst());
//poll()和pollFirst()是等价的
// System.out.println("poll:"+queue.poll());
System.out.println("poll:"+deque.pollFirst());
//remove和removeFirst()是等价的
// System.out.println("remove:"+deque.remove());
// System.out.println("removeFirst:"+deque.removeFirst());
}
}
@Test
public void test3() throws Exception {
Deque<String> deque=new LinkedList<>();
//往尾部插入
deque.add("test");
deque.add("test2");
deque.add("test3");
deque.addLast("test4");
deque.addLast("test5");
//往头部插入
deque.offerFirst("test6");
deque.offerFirst("test7");
deque.offerFirst("test8");
deque.offerFirst("test9");
deque.offerFirst("test10");
int size=deque.size();
System.out.println(size);
for(int i=0;i<size+1;i++){
//返回尾部最后一个元素，不移除，队列为空返回null
System.out.println("peekLast:"+deque.peekLast());
//返回尾部最后一个元素，不移除，队列为空抛出异常
// System.out.println("getLast:"+deque.getLast());
//返回并移除尾部最后一个元素，队列为空返回null
// System.out.println("pollLast"+deque.pollLast());
//返回并移除尾部最后一个元素，队列为空抛出异常
System.out.println("removeLast:"+deque.removeLast());
}
}
@Test
public void test4() throws Exception {
//Deque当做一个堆栈Stack使用
Deque<String> deque=new LinkedList<>();
//push()相当于addFirst()
deque.push("test");
deque.push("test2");
deque.push("test3");
deque.addFirst("test4");
deque.addFirst("test5");
int size=deque.size();
System.out.println(size);
for(int i=0;i<size+1;i++){
//返回并移除头部最后一个元素，队列为空抛出异常，等价于removeLast()
System.out.println("pop:"+deque.pop());
// System.out.println("removeLast:"+deque.removeFirst());
}
}
@Test
public void test5() throws Exception {
//Deque当做一个堆栈Stack使用
Deque<String> deque=new LinkedList<>();
deque.add("test");
deque.add("test2");
deque.add("test3");
deque.addLast("test4");
deque.addLast("test5");
int size=deque.size();
System.out.println(size);
for(int i=0;i<size+1;i++){
System.out.println("pop:"+deque.removeLast());
}
}
@Test
public void test6() throws Exception {
Deque<String> deque=new LinkedList<>();
deque.add("test");
deque.add("test2");
deque.add("test3");
deque.addLast("test4");
deque.addLast("test5");
deque.addLast("test2");
deque.addLast("test6");
int size=deque.size();
System.out.println(size);
//移除第一次的test2
System.out.println("removeFirstOccurrence:"+deque.removeFirstOccurrence("test2"));
//移除最后一次的test2
System.out.println("removeFirstOccurrence:"+deque.removeLastOccurrence("test2"));
System.out.println("==========iterator======== ");
//顺序遍历
Iterator<String> iterator=deque.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("==========descendingIterator======== ");
//倒序遍历
Iterator<String> desIterator=deque.descendingIterator();
while (desIterator.hasNext()){
System.out.println(desIterator.next());
}
}三、接口实现
1、AbstractSequentialList
AbstractSequentialList是List接口的基础实现类，继承自AbstractList，不过与其功能相反。AbstractList表示随机访问元素的列表，AbstractSequentialList表示顺序访问元素的列表。AbstractSequentialList改写了AbstractList中获取和修改元素的实现，通过ListIterator完成元素的增删改查。如下：
public E get(int index) {
try {
return listIterator(index).next();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
public E set(int index, E element) {
try {
ListIterator<E> e = listIterator(index);
E oldVal = e.next();
e.set(element);
return oldVal;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
public E remove(int index) {
try {
ListIterator<E> e = listIterator(index);
E outCast = e.next();
e.remove();
return outCast;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
public void add(int index, E element) {
try {
listIterator(index).add(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
2、LInkedList
LinkedList基于双向链表实现List和Deque两个接口，允许元素为空,当做Deque使用时不能插入null元素，非同步，遍历时修改快速失败。ArrayList是根据元素在列表中位置随机访问元素很快，LinkedList是按照元素插入的顺序遍历列表元素很快，没有实现RandomAccess接口。
2.1 链表节点实现类
//链表节点实现类
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;
}
}2.2 全局属性和公用方法
//元素个数
transient int size = 0;
/**
* 链表第一个元素
*/
transient Node<E> first;
/**
* 链表最后一个元素
*/
transient Node<E> last;
/**
* 将目标元素插入到链表头
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
//新元素置为first
first = newNode;
//原来的头元素为空，即链表为空
if (f == null)
//将新元素置为last
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
last = newNode;
//原来的last为null，即链表为空
if (l == null)
//新元素置为first
first = newNode;
else
//新元素插入到原来的last的后面
l.next = newNode;
size++;
modCount++;
}
/**
* 将目标元素插入到指定节点的前面，这里假定succ不为null
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
//建立newNode同前后节点的关联
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
//前一个元素为空表明succ为头元素
if (pred == null)
//将新元素置为first
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
/**
* 去掉first元素
*/
private E unlinkFirst(Node<E> f) {
//假定f为头元素且不为空
final E element = f.item;
final Node<E> next = f.next;
//头元素保留的引用置null
f.item = null;
f.next = null;
//下一个元素置为first
first = next;
//next为空说明该队列只有一个元素，删除后需要将last置为null
if (next == null)
last = null;
else
//将下一个元素对头元素的引用置null
next.prev = null;
size--;
modCount++;
return element;
}
/**
* 去掉last元素
*/
private E unlinkLast(Node<E> l) {
//假定l为last，且不为空
final E element = l.item;
final Node<E> prev = l.prev;
//保留的引用置为null
l.item = null;
l.prev = null; // help GC
//前一个元素置为last
last = prev;
//前一个元素为空，表名当前链表只有一个元素，删除后first置null
if (prev == null)
first = null;
else
//去掉前一个元素对原last的引用
prev.next = null;
size--;
modCount++;
return element;
}
/**
* 去除节点x
*/
E unlink(Node<E> x) {
//假定x不为null
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {//x是头元素
first = next;//下一个元素置为first
} else {
prev.next = next;//前一个元素的下一个元素为x的下一个元素
x.prev = null;
}
if (next == null) {//x是尾元素
last = prev;//前一个元素置为last
} else {
next.prev = prev;//x的下一个元素的前一个元素为x的前一个元素
x.next = null;
}
x.item = null;//x所有的引用置为null
size--;
modCount++;
return element;
}
/**
* 查找目标索引的节点，因为是通过遍历的方式查找所以效率比ArrayList通过下标随机访问元素慢
*/
Node<E> node(int index) {
if (index < (size >> 1)) {//如果位于前一半的链表，则从first顺序遍历
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//如果位于后一半的链表，则从last倒序遍历
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}2.3 构造方法
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}2.4 添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
//将指定元素插入到目标索引index处
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)//插入到链表末尾
linkLast(element);
else
linkBefore(element, node(index));//插入到某个元素的前面
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 将目标集合的所有元素插入到链表index处
*/
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index); //校验index必须小于等于size
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//succ为目标索引index处的节点
//pred为succ的前一个节点
Node<E> pred, succ;
if (index == size) {//表示插入到链表的末尾
succ = null;
pred = last;//pred为last
} else {
succ = node(index);//找到指定index的元素
pred = succ.prev;
}
//不断的插入到pred的后面
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)//succ为头元素
first = newNode;
else
pred.next = newNode;
//pred置为最后一个插入的新节点
pred = newNode;
}
if (succ == null) {//原链表为空
last = pred;//pred置为last
} else {
//pred插入到succ的前面
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}2.5 元素查找
public E get(int index) {
checkElementIndex(index);//校验index小于等于size
return node(index).item;
}
/**
* 顺序遍历链表查找目标元素
*/
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;
}
//倒序查找目标元素
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;
}2.6 元素修改
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}2.7 元素删除
//先顺序遍历找到目标元素，然后解除该元素的链式关系
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;
}
public E remove(int index) {
checkElementIndex(index);//校验index小于等于size
return unlink(node(index));
}
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//倒序遍历查找目标元素
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;
}
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);//去掉原来的尾元素
}
2.8 元素遍历
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;//重置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;//将lastReturned和next重置为next的前一个元素
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);//去除lastReturned节点的链式关系
if (next == lastReturned)//如果倒序遍历，被删除元素会被lastNext替代，下一个元素为该元素的上一个元素
next = lastNext;
else
nextIndex--;//如果是正序遍历，下一个元素还是lastReturned的下一个元素，保持不变，但是因为size减一了，此处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();
}
}
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}