本文共 10884 字，大约阅读时间需要 36 分钟。
public class ArrayDequeextends AbstractCollection implements Deque , Cloneable, Serializable
1.实现了Deque使其具有作为双端队列和作为栈的能力。
2.实现了Cloneable它可克隆。 3.实现了Serializable表明可序列化。 4.（没有实现RandomAccess，表明不支持随机访问）。 5.使用循环数组（后面会提到） ArrayDeque与早期继承与Vector的Stack不同，ArrayDeque是非线程安全的，不支持并发修改（只能在外部进行同步），支持快速失败public class LinkedListextends AbstractSequentialList implements List , Deque , Cloneable, java.io.Serializable
1.实现了List接口，表明LinkList具有随机存取的能力
2.实现了Deque使其具有作为双端队列和作为栈的能力。 3.实现了Cloneable它可克隆。 4.实现了Serializable表明可序列化。 5.使用双向链表 LinkList是非线程安全的，不支持并发修改，支持快速失败public ArrayDeque() { elements = new Object[16]; } public ArrayDeque(int numElements) { allocateElements(numElements); } private void allocateElements(int numElements) { elements = new Object[calculateSize(numElements)]; } private static int calculateSize(int numElements) { int initialCapacity = MIN_INITIAL_CAPACITY; // Find the best power of two to hold elements. // Tests "<=" because arrays aren't kept full. if (numElements >= initialCapacity) { initialCapacity = numElements; initialCapacity |= (initialCapacity >>> 1); initialCapacity |= (initialCapacity >>> 2); initialCapacity |= (initialCapacity >>> 4); initialCapacity |= (initialCapacity >>> 8); initialCapacity |= (initialCapacity >>> 16); initialCapacity++; if (initialCapacity < 0) // Too many elements, must back off initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements } return initialCapacity; } 添加元素采用移动head或tail指针的方式，使得添加元素过程的复杂度为O(0)。
容量为2的次幂的原因是元素添加的方式（元素添加时使用head-1和length-1相与的形式来计算，在这个运算中必须保证length-1的结果二进制表示必须是全1序列。）。/** * Inserts the specified element at the front of this deque. * * @param e the element to add * @throws NullPointerException if the specified element is null */ public void addFirst(E e) { if (e == null) throw new NullPointerException(); elements[head = (head - 1) & (elements.length - 1)] = e; if (head == tail) doubleCapacity(); } /** * Inserts the specified element at the end of this deque. * * This method is equivalent to {@link #add}. * * @param e the element to add * @throws NullPointerException if the specified element is null */ public void addLast(E e) {
if (e == null) throw new NullPointerException(); elements[tail] = e; if ( (tail = (tail + 1) & (elements.length - 1)) == head) doubleCapacity(); } 同时也可以由addFirst添加元素的方式知道：ArrayDeque使用的是循环数组。
删除元素采用移动head或tail指针的方式，使得删除元素过程的复杂度为O(0)。
public E pollFirst() { int h = head; @SuppressWarnings("unchecked") E result = (E) elements[h]; // Element is null if deque empty if (result == null) return null; elements[h] = null; // Must null out slot head = (h + 1) & (elements.length - 1); return result; } public E pollLast() { int t = (tail - 1) & (elements.length - 1); @SuppressWarnings("unchecked") E result = (E) elements[t]; if (result == null) return null; elements[t] = null; tail = t; return result; } 将原数组中元素复制到新数组中，第一个元素下标为0，最后一个元素下标为原数组长度。
/** * Doubles the capacity of this deque. Call only when full, i.e., * when head and tail have wrapped around to become equal. */ private void doubleCapacity() { assert head == tail; int p = head; int n = elements.length; int r = n - p; // number of elements to the right of p int newCapacity = n << 1; if (newCapacity < 0) throw new IllegalStateException("Sorry, deque too big"); Object[] a = new Object[newCapacity]; System.arraycopy(elements, p, a, 0, r); System.arraycopy(elements, 0, a, r, p); elements = a; head = 0; tail = n; } LinkList类中维护一个size，两个Node指针first和last：
transient int size = 0;transient Nodefirst;transient Node last;
private static class Node{ E item; Node next; Node prev; Node(Node prev, E element, Node next) { this.item = element; this.next = next; this.prev = prev; } }
表明LinkList使用的是双向链表的存储结构。
对外提供的添加首尾元素的方法都调用如下两个方法实现添加功能（如addFirst(E e) 方法）：
/** * Inserts the specified element at the beginning of this list. * * @param e the element to add */ public void addFirst(E e) { linkFirst(e); } /** * Links e as first element. */ private void linkFirst(E e) { final Node f = first; final Node newNode = new Node<>(null, e, f); first = newNode; if (f == null) last = newNode; else f.prev = newNode; size++; modCount++; } /** * Links e as last element. */ void linkLast(E e) { final Node l = last; final Node newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; } 在双向链表的存储结构下，首尾元素添加都能获得O(0)的时间复杂度，
对外提供的随机添加元素的方法都调用如下方法实现添加功能（如add(int index, E element) 方法）：
//在随机位置添加元素的方法 public void add(int index, E element) { checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); } void linkBefore(E e, Node succ) { // assert succ != null; final Node pred = succ.prev; final Node newNode = new Node<>(pred, e, succ); succ.prev = newNode; if (pred == null) first = newNode; else pred.next = newNode; size++; modCount++; } /** * Returns the (non-null) Node at the specified element index. */ Node node(int index) { // assert isElementIndex(index); if (index < (size >> 1)) { Node x = first; for (int i = 0; i < index; i++) x = x.next; return x; } else { Node x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } } 随机添加过程：
1.检查参数传递的下标index是否合法（在[0,size]范围内：index >= 0 && index <= size;） 2.判断添加位置是否为双链表的尾部（index == size）如果为尾部就调用尾部添加元素的方法（linkLast）， 3.如果不是添加到尾部，调用node(int index)方法找到待添加节点的后继，将待添加元素和node方法返回的节点作为参数传递给linkBefore（E e,Node<E>succ）完成添加功能。 node(int index)方法说明：该方法返回查找指定下标位置的节点，通过将双链分为前后两部分(size >> 1)来提高查找的效率，使查找时间减半。
对外提供的删除首尾元素的方法都调用如下两个方法实现添加功能（如removeFirst() 和removeLast() 方法）：
/** * 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 f = first; if (f == null) throw new NoSuchElementException(); return unlinkFirst(f); } /** * Removes and returns the last element from this list. * * @return the last element from this list * @throws NoSuchElementException if this list is empty */ public E removeLast() { final Node l = last; if (l == null) throw new NoSuchElementException(); return unlinkLast(l); } /** * Unlinks non-null first node f. */ private E unlinkFirst(Node f) { // assert f == first && f != null; final E element = f.item; final Node 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 l) { // assert l == last && l != null; final E element = l.item; final Node 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; } 头部删除（
removeFirst()）和尾部删除（removeLast()）都在进入实际删除节点的方法前（unlinkFirst(Node<E> f)，unlinkLast(Node<E> l)）对节点进行了空检查，实际删除节点的工作通过将节点与双链断开的方式完成。删除的方法将被删除的元素值作为返回值返回。
随机位置删除通过调用node节点方法查找到合适待删除节点，然后调用方法完成删除功能。
/** * Removes the element at the specified position in this list. Shifts any * subsequent elements to the left (subtracts one from their indices). * Returns the element that was removed from the list. * * @param index the index of the element to be removed * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */ public E remove(int index) { checkElementIndex(index); return unlink(node(index)); } /** * Unlinks non-null node x. */ E unlink(Node x) { // assert x != null; final E element = x.item; final Node next = x.next; final Node 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; } 实际删除节点的方法
E unlink(Node<E> x)也是通过将节点与双链断开的方式完成。
publicclass Stackextends Vector
Stack的在Vector的基础上添加的栈的几个方法，这几个方法被synchronized关键字修饰，使得Stack具有了同步功能。
1.在头尾插入节点的性能：ArrayDeque使用循环数组存储，元素的添加和删除采用移动head和tail的方式实现效率很好（时间复杂度为O(0)），但是数组存在扩容过程对效率有一定影响。 LinkList使用双链表存储数据，虽然元素的添加和删除时间复杂度也是O(0)，并且没有扩容的时间开销，但是双链表的元素添加过程每次都会创建新的节点，使得其插入插入效率低于ArrayDeque。
2.在头尾删除节点的性能：ArrayDeque和LinkList在头尾删除节点都具有O(0)的时间复杂度，性能上“相差不多”（）。 结论：ArrayDeque性能总体优于LinkListStack继承自Vector，由于Vector使用简单数组存储结构，并不是像ArrayDeque那样的循环数组存储结构，导致Stack的性能比ArrayDeque差很多（主要由于删除元素时Stack的实现方式是前移待删除元素之后的所有元素，时间复杂度为O(n)），而ArrayDeque是通过更改头指针来实现。
结论：在实现栈时，ArrayDeque性能优于Stack。如果需要同步ArrayDeque可以“在外部进行同步”（JDK1.8文档）。转载地址：http://xttgz.baihongyu.com/