ArrayDeque双向队列，底层是数组。两个方向都可以插入和删除。作为栈时，效率超过Stack，作为队列的时候，效率超过LinkedList。
属性
/**
* 用来承装数据的数据
*/
transient Object[] elements; // non-private to simplify nested class access
/**
* 头索引
*/
transient int head;
/**
* 尾索引
*/
transient int tail;
/**
* 数组的最小容量
*/
private static final int MIN_INITIAL_CAPACITY = 8;
构造器
ArrayDeque()
默认构造器，默认创建容量是16的数组
public ArrayDeque() {
elements = new Object[16];
}
ArrayDeque(int numElements)
用户传入容量值
public ArrayDeque(int numElements) {
allocateElements(numElements);
}
/**
* 重新计算容量的大小，返回的是里numElements最小的2的幂次
*/
private void allocateElements(int numElements) {
elements = new Object[calculateSize(numElements)];
}
private static int calculateSize(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
// 通过位运算得到最近的2的幂次，如果是6，得到是8，如果是16，得到的是32，如果是7得到的是8.
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;
}
ArrayDeque(Collection<? extends E> c)
传入的是一个列表
public ArrayDeque(Collection<? extends E> c) {
// 重新计算容量，创建数组
allocateElements(c.size());
// 调用AbstracCollection类的addALL,自身没有重写该方法
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
public boolean add(E e) {
//默认是添加在最后的
addLast(e);
return true;
}
// 一开始head和tail都是0，
// 需要注意的是如果数组的长度是8，head添加是添加的索引是7，tail添加的索引是0
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
// 设置数据
elements[tail] = e;
// 重新计算tail的值
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity();
}
添加操作
add()和addLast()已经介绍过了
addFirst(E e)
public void addFirst(E e) {
if (e == null)
throw new NullPointerException();
// 先计算head的值，由于head指向的是数据所以最大的位置，下次添加的时候要向前移动
// 之后再添加数据
elements[head = (head - 1) & (elements.length - 1)] = e;
if (head == tail)
doubleCapacity();
}
注意，头索引是先计算后添加，而尾索引是先添加后计算；也就是说头索引指向的最近添加的数据，而尾索引指向的是添加位置的索引。头结点指向的是索引最大的位置，下次添加的时候向前移动，而尾索引指向的是索引最小的位置，下次添加的时候直接向后移动
队列的添加方法
栈的添加方法
默认是添加在头。
删除，这里是出栈或者出队列的操作
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;
}
pollLast()
public E pollLast() {
// 先计算tail的值
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;
}
其他方法
出栈方法
查询方法
这里需要住一个是getLast()方法，由于尾指针指向的是要添加的位置，索引要退回一个索引，查询是的时候先计算tail的位置。
队列的方法
扩容
注意到在添加的时候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];
// 先拷贝头指针添加的
System.arraycopy(elements, p, a, 0, r);
// 再拷贝尾指针添加的
System.arraycopy(elements, 0, a, r, p);
elements = a;
head = 0;
tail = n;
}
head指向的是最近添加的数据，所以5是head指针添加的
5406
