类的描述
-
public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable
通过可调整大小的数组实现Deque的接口。阵列的双端队列没有容量限制；它们根据需要增长以支持使用。他们不是线程安全的；；在没有外部同步的情况下，它们不支持多线程并发访问。禁止空元素。这个类在用作堆栈时可能比 Stack 更快，当用作队列时比 LinkedList 更快。大多数 ArrayDeque 操作在分摊的常数时间内运行。例外情况包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 和批量操作，所有这些都在线性时间内运行。
此类的迭代器方法返回的迭代器是fail-fast：如果在迭代器创建后的任何时间修改双端队列，除了通过迭代器自己的 remove 方法外，迭代器通常会抛出 ConcurrentModificationException。因此，面对并发修改，迭代器快速而干净地失败，而不是冒着在未来不确定的时间出现任意、非确定性行为的风险。
请注意，无法保证迭代器的快速失败行为，因为一般而言，在存在非同步并发修改的情况下不可能做出任何硬保证。快速失败的迭代器会尽最大努力抛出 ConcurrentModificationException。因此，编写一个依赖此异常来确保其正确性的程序是错误的：迭代器的快速失败行为应该仅用于检测错误。
此类及其迭代器实现了 Collection 和 Iterator 接口的所有可选方法
常量、变量、静态内部类
transient Object[] elements; // non-private to simplify nested class access
// 头部元素的索引
transient int head;
//尾部下一个将要被加入的元素的索引
transient int tail;
/**
* The minimum capacity that we'll use for a newly created deque.
* Must be a power of 2.
*/
private static final int MIN_INITIAL_CAPACITY = 8;
// ****** Array allocation and resizing utilities ******
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;
}这里的实现很有意思，对于一个小于2^30的值，经过五次右移和位或操作后，可以得到一个2^k - 1的值。最后再将这个值+1，得到2^k。通过这个方法，可以将一个任意的初始值转化为2^n的值，不过有一点不足在于，如果本身传进来的值就是2^n的值，那么经过转化会变成2^(n+1)，所以我们在不用刻意去传入2^n的值。还有一点在于，如果传入的值大于等于2^30，那么经过转化会变成负值，即< 0，此时会把初始值设置为2^30，即最大的容量只有2^30。
构造方法
public ArrayDeque() {
elements = new Object[16];
}
public ArrayDeque(int numElements) {
allocateElements(numElements);
}
public ArrayDeque(Collection<? extends E> c) {
allocateElements(c.size());
addAll(c);
}
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;
}
这里的实现很有意思，对于一个小于2^30的值，经过五次右移和位或操作后，可以得到一个2^k - 1的值。最后再将这个值+1，得到2^k。通过这个方法，可以将一个任意的初始值转化为2^n的值，不过有一点不足在于，如果本身传进来的值就是2^n的值，那么经过转化会变成2^(n+1)，所以我们在不用刻意去传入2^n的值。还有一点在于，如果传入的值大于等于2^30，那么经过转化会变成负值，即< 0，此时会把初始值设置为2^30，即最大的容量只有2^30。
队列中常用的方法
add
public void addFirst(E e) {
if (e == null)
throw new NullPointerException();
// 本来可以简单地写成head-1，但如果head为0，减1就变为-1了，和elements.length - 1进行与操作就是为了处理这种情况，这时结果为elements.length - 1。
elements[head = (head - 1) & (elements.length - 1)] = e;
if (head == tail)
doubleCapacity();
}
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
elements[tail] = e;
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity();
}
public boolean add(E e) {
addLast(e);
return true;
}
//扩容, 二倍, 只有head==tail时才扩容
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];
//左测的数据，0到tail位置的元素
System.arraycopy(elements, p, a, 0, r);
//右侧的数据head位置到数组末尾的位置
System.arraycopy(elements, 0, a, r, p);
elements = a;
head = 0;
tail = n;
}
//上面为什么这样做，在后面看完remove进行解释
// 调用的AbstractCollection的addAll
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e)) //这里调用的是自己的add
modified = true;
return modified;
}offer
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
public boolean offer(E e) {
return offerLast(e);
}remove
public E removeFirst() {
E x = pollFirst();
if (x == null)
throw new NoSuchElementException();
return x;
}
/**
* @throws NoSuchElementException {@inheritDoc}
*/
public E removeLast() {
E x = pollLast();
if (x == null)
throw new NoSuchElementException();
return x;
}
public boolean removeFirstOccurrence(Object o) {
if (o == null)
return false;
int mask = elements.length - 1;
int i = head;
Object x;
while ( (x = elements[i]) != null) {
if (o.equals(x)) {
delete(i);
return true;
}
i = (i + 1) & mask;
}
return false;
}
private boolean delete(int i) {
checkInvariants();
final Object[] elements = this.elements;
final int mask = elements.length - 1;
final int h = head;
final int t = tail;
final int front = (i - h) & mask;
final int back = (t - i) & mask;
// Invariant: head <= i < tail mod circularity
if (front >= ((t - h) & mask))
throw new ConcurrentModificationException();
// Optimize for least element motion
if (front < back) {
if (h <= i) {
System.arraycopy(elements, h, elements, h + 1, front);
} else { // Wrap around
System.arraycopy(elements, 0, elements, 1, i);
elements[0] = elements[mask];
System.arraycopy(elements, h, elements, h + 1, mask - h);
}
elements[h] = null;
head = (h + 1) & mask;
return false;
} else {
if (i < t) { // Copy the null tail as well
System.arraycopy(elements, i + 1, elements, i, back);
tail = t - 1;
} else { // Wrap around
System.arraycopy(elements, i + 1, elements, i, mask - i);
elements[mask] = elements[0];
System.arraycopy(elements, 1, elements, 0, t);
tail = (t - 1) & mask;
}
return true;
}
}poll
public E poll() {
return pollFirst();
}
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;
}看到这里，我们发现，，存储元素时Object数组，但在存储数据时候，并不是前面的元素，一定在数组的索引靠前的位置，其实是一个环的数据结构，然后通过head和tail指针来控制队列的第一个元素，和最后一个元素的为位置，详细的解释，请看下面的参考文章
peek
@SuppressWarnings("unchecked")
public E peekFirst() {
// elements[head] is null if deque empty
return (E) elements[head];
}
@SuppressWarnings("unchecked")
public E peekLast() {
return (E) elements[(tail - 1) & (elements.length - 1)];
}element
public E element() {
return getFirst();
}
public E getFirst() {
@SuppressWarnings("unchecked")
E result = (E) elements[head];
if (result == null)
throw new NoSuchElementException();
return result;
}
/**
* @throws NoSuchElementException {@inheritDoc}
*/
public E getLast() {
@SuppressWarnings("unchecked")
E result = (E) elements[(tail - 1) & (elements.length - 1)];
if (result == null)
throw new NoSuchElementException();
return result;
}更详细的解释，请看这个文档
参考文档：
‘(1条消息) Java集合源码分析之Queue（三）：ArrayDeque_maxiaoyin111111的博客-CSDN博客
结论
1. ArrayDeque是通过数组来存储元素的，
2. 数据结构是实际是一个环状，通过head和tail指针来控制队列的弹出和put的位置。当head和tail指针指向同一个位置的时候，进行扩容。 扩容的时候直接扩二倍
2. 不是线程安全的
3. 是双向队列
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
