deque 是“double ended queue(双端队列)”的缩写,通常读为“deck”
双端队列就是一个两端都是结尾的队列。队列的每一瑞都可以插入数据项和移除数据项。这些方法可以叫作insertLeft()和insertRight(),以及removeLeft()和removeRight()。如果严格禁止调用insertLeft()和removeLeft()方法(或禁用右段的操作),双端队列功能就和栈一样。禁止调用insertLeft()和removeRight()(或相反的另一对方法),它的功能就和队列一样了。双端队列与栈或队列相比,是一种多用途的数据结构,在容器类库中有时会用双端队列来提供栈和队列两种功能。
public interface Dequeextends Queue
一个线性 collection,支持在两端插入和移除元素。名称 deque 是“double ended queue(双端队列)”的缩写,通常读为“deck”。大多数Deque 实现对于它们能够包含的元素数没有固定限制,但此接口既支持有容量限制的双端队列,也支持没有固定大小限制的双端队列。
此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式:一种形式在操作失败时抛出异常,另一种形式返回一个特殊值(null 或false,具体取决于操作)。插入操作的后一种形式是专为使用有容量限制的Deque 实现设计的;在大多数实现中,插入操作不能失败。
下表总结了上述 12 种方法:
第一个元素(头部) | 最后一个元素(尾部) | |||
抛出异常 | 特殊值 | 抛出异常 | 特殊值 | |
插入 | addFirst(e) |
offerFirst(e) |
addLast(e) |
offerLast(e) |
移除 | removeFirst() |
pollFirst() |
removeLast() |
pollLast() |
检查 | getFirst() |
peekFirst() |
getLast() |
peekLast() |
此接口扩展了 Queue
接口。在将双端队列用作队列时,将得到 FIFO(先进先出)行为。将元素添加到双端队列的末尾,从双端队列的开头移除元素。从Queue 接口继承的方法完全等效于Deque 方法,如下表所示:
Queue 方法 | 等效 Deque 方法 |
add(e) |
addLast(e) |
offer(e) |
offerLast(e) |
remove() |
removeFirst() |
poll() |
pollFirst() |
element() |
getFirst() |
peek() |
peekFirst() |
双端队列也可用作 LIFO(后进先出)堆栈。应优先使用此接口而不是遗留 Stack
类。在将双端队列用作堆栈时,元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque 方法,如下表所示:
堆栈方法 | 等效 Deque 方法 |
push(e) |
addFirst(e) |
pop() |
removeFirst() |
peek() |
peekFirst() |
注意,在将双端队列用作队列或堆栈时,peek
方法同样正常工作;无论哪种情况下,都从双端队列的开头抽取元素。
此接口提供了两种移除内部元素的方法:removeFirstOccurrence
和removeLastOccurrence
。
与 List
接口不同,此接口不支持通过索引访问元素。
虽然 Deque 实现没有严格要求禁止插入 null 元素,但建议最好这样做。建议任何事实上允许 null 元素的 Deque 实现用户最好不 要利用插入 null 的功能。这是因为各种方法会将null 用作特殊的返回值来指示双端队列为空。
Deque 实现通常不定义基于元素的 equals 和 hashCode 方法,而是从 Object 类继承基于身份的equals 和hashCode 方法。
此接口是 Java Collections Framework 的成员。
先看LinkedList类的定义。
1 public class LinkedList2 extends AbstractSequentialList 3 implements List , Deque , Cloneable, java.io.Serializable
LinkedList继承自AbstractSequenceList、实现了List及Deque接口。其实AbstractSequenceList已经实现了List接口,这里标注出List只是更加清晰而已。AbstractSequenceList提供了List接口骨干性的实现以减少实现List接口的复杂度。Deque接口定义了双端队列的操作。
LinkedList中之定义了两个属性:
1 private transient Entryheader = new Entry (null, null, null); 2 private transient int size = 0;
size肯定就是LinkedList对象里面存储的元素个数了。LinkedList既然是基于链表实现的,那么这个header肯定就是链表的头结点了,Entry就是节点对象了。一下是Entry类的代码。
1 private static class Entry{ 2 E element; 3 Entry next; 4 Entry previous; 5 6 Entry(E element, Entry next, Entry previous) { 7 this.element = element; 8 this.next = next; 9 this.previous = previous; 10 } 11 }
只定义了存储的元素、前一个元素、后一个元素,这就是双向链表的节点的定义,每个节点只知道自己的前一个节点和后一个节点。
来看LinkedList的构造方法。
1 public LinkedList() { 2 header.next = header.previous = header; 3 } 4 public LinkedList(Collection extends E> c) { 5 this(); 6 addAll(c); 7 }
LinkedList提供了两个构造方法。第一个构造方法不接受参数,只是将header节点的前一节点和后一节点都设置为自身(注意,这个是一个双向循环链表,如果不是循环链表,空链表的情况应该是header节点的前一节点和后一节点均为null),这样整个链表其实就只有header一个节点,用于表示一个空的链表。第二个构造方法接收一个Collection参数c,调用第一个构造方法构造一个空的链表,之后通过addAll将c中的元素全部添加到链表中。来看addAll的内容。
1 public boolean addAll(Collection extends E> c) { 2 return addAll(size, c); 3 } 4 // index参数指定collection中插入的第一个元素的位置 5 public boolean addAll(int index, Collection extends E> c) { 6 // 插入位置超过了链表的长度或小于0,报IndexOutOfBoundsException异常 7 if (index < 0 || index > size) 8 throw new IndexOutOfBoundsException("Index: "+index+ 9 ", Size: "+size); 10 Object[] a = c.toArray(); 11 int numNew = a.length; 12 // 若需要插入的节点个数为0则返回false,表示没有插入元素 13 if (numNew==0) 14 return false; 15 modCount++; 16 // 保存index处的节点。插入位置如果是size,则在头结点前面插入,否则获取index处的节点 17 Entrysuccessor = (index==size ? header : entry(index)); 18 // 获取前一个节点,插入时需要修改这个节点的next引用 19 Entry predecessor = successor.previous; 20 // 按顺序将a数组中的第一个元素插入到index处,将之后的元素插在这个元素后面 21 for (int i=0; i ) { 22 // 结合Entry的构造方法,这条语句是插入操作,相当于C语言中链表中插入节点并修改指针 23 Entry e = new Entry ((E)a[i], successor, predecessor); 24 // 插入节点后将前一节点的next指向当前节点,相当于修改前一节点的next指针 25 predecessor.next = e; 26 // 相当于C语言中成功插入元素后将指针向后移动一个位置以实现循环的功能 27 predecessor = e; 28 } 29 // 插入元素前index处的元素链接到插入的Collection的最后一个节点 30 successor.previous = predecessor; 31 // 修改size 32 size += numNew; 33 return true; 34 }
构造方法中的调用了addAll(Collection extends E>c)方法,而在addAll(Collection extends E>c)方法中仅仅是将size当做index参数调用了addAll(int index,Collection extends E>c)方法。
1 private Entryentry(int index) { 2 if (index < 0 || index >= size) 3 throw new IndexOutOfBoundsException("Index: "+index+ 4 ", Size: "+size); 5 Entry e = header; 6 // 根据这个判断决定从哪个方向遍历这个链表 7 if (index < (size >> 1)) { 8 for (int i = 0; i <= index; i++) 9 e = e.next; 10 } else { 11 // 可以通过header节点向前遍历,说明这个一个循环双向链表,header的previous指向链表的最后一个节点,这也验证了构造方法中对于header节点的前后节点均指向自己的解释 12 for (int i = size; i > index; i--) 13 e = e.previous; 14 } 15 return e; 16 }
结合上面代码中的注释及双向循环链表的知识,应该很容易理解LinkedList构造方法所涉及的内容。下面开始分析LinkedList的其他方法。
addFirst(E e)
1 public void addFirst(E e) { 2 addBefore(e, header.next); 3 }
1 private EntryaddBefore(E e, Entry entry) { 2 Entry newEntry = new Entry (e, entry, entry.previous); 3 newEntry.previous.next = newEntry; 4 newEntry.next.previous = newEntry; 5 size++; 6 modCount++; 7 return newEntry; 8 }
removeFirst()
1 public E removeFirst() { 2 return remove(header.next); 3 }
几个remove方法最终都是调用了一个私有方法:remove(Entry
1 private E remove(Entrye) { 2 if (e == header) 3 throw new NoSuchElementException(); 4 // 保留将被移除的节点e的内容 5 E result = e.element; 6 // 将前一节点的next引用赋值为e的下一节点 7 e.previous.next = e.next; 8 // 将e的下一节点的previous赋值为e的上一节点 9 e.next.previous = e.previous; 10 // 上面两条语句的执行已经导致了无法在链表中访问到e节点,而下面解除了e节点对前后节点的引用 11 e.next = e.previous = null; 12 // 将被移除的节点的内容设为null 13 e.element = null; 14 // 修改size大小 15 size--; 16 modCount++; 17 // 返回移除节点e的内容 18 return result; 19 }
getFirst()
1 public E getFirst() { 2 if (size==0) 3 throw new NoSuchElementException(); 4 return header.next.element; 5 }
offerFirst(E e)
1 public boolean offerFirst(E e) { 2 addFirst(e); 3 return true; 4 }
在链表开头插入元素。
1 public void addFirst(E e) { 2 addBefore(e, header.next); 3 }
pollFirst()
1 public E pollFirst() { 2 if (size==0) 3 return null; 4 return removeFirst(); 5 }
1 public E removeFirst() { 2 return remove(header.next); 3 }
peekFirst()
1 public E peekFirst() { 2 if (size==0) 3 return null; 4 return getFirst(); 5 }
addLast(E e)
1 public void addLast(E e) { 2 addBefore(e, header); 3 }
看上面的示意图,结合addBefore(E e,Entry
removeLast()
1 public E removeLast() { 2 return remove(header.previous); 3 }
getLast()
1 public E getLast() { 2 if (size==0) 3 throw new NoSuchElementException(); 4 return header.previous.element; 5 }
getLast()方法和getFirst()方法类似,只是获取的是header节点的前一个节点的元素。因为是循环链表,所以header节点的前一节点就是链表的最后一个节点。
offerLast(E e)
1 public boolean offerLast(E e) { 2 addLast(e); 3 return true; 4 }
在链表末尾插入元素。
pollLast()
1 public E pollLast() { 2 if (size==0) 3 return null; 4 return removeLast(); 5 }
peekLast()
1 public E peekLast() { 2 if (size==0) 3 return null; 4 return getLast(); 5 }
上面的三个方法也很简单,只是调用了对应的get方法。
1 public E getLast() { 2 if (size==0) 3 throw new NoSuchElementException(); 4 return header.previous.element; 5 }
getLast()方法和getFirst()方法类似,只是获取的是header节点的前一个节点的元素。因为是循环链表,所以header节点的前一节点就是链表的最后一个节点。