Java集合框架分析(Deque)———ArrayDeque类详解
目录
- 一.数据结构
- 二.类标题
- 三.字段
- 四.构造函数
- 五.方法分析
- 六.参考资料
一.数据结构
ArrayDeque类是 双端队列的线性实现类。具有以下特征:
☞ ArrayDeque是采用数组方式实现的双端队列。
☞ ArrayDeque的出队入队是通过头尾指针循环,利用数组实现的。
☞ ArrayDeque容量不足时是会扩容的,每次扩容容量增加一倍。
☞ ArrayDeque可以直接作为栈使用。当用作栈时,性能优于Stack,当用于队列时,性能优于LinkedList。
☞ 无容量大小限制,容量按需增长。
☞ 非线程安全队列,无同步策略,不支持多线程安全访问。
☞ 具有fail-fast特性,不能存储null值,支持双向迭代器遍历。
ArrayDeque的实现结构图如下所示:
二.类标题
ArrayDeque类的标题如下:public class ArrayDeque extends AbstractCollection implements Deque, Cloneable, Serializable
这个标题说明ArrayDeque类是AbstractCollection类的子类,并且实现了三个接口:Deque、Cloneable和Serializable。
如下图所示:
1.ArrayDeque实现了Deque接口,即能将LinkedList当做双端队列使用。
2.ArrayDeque实现了Cloneable接口,即覆盖了函数clone(),能克隆。
3.ArrayDeque实现java.io.Serializable接口,LinkedList支持序列化,能通过序列化去传输。
4.ArrayDeque是非同步的[2]。
【注2】在这里的非同步指的是,当使用线程的时候,对于这个集合对象进行操作,那么不同的线程所获取的这个集合对象是不同的.所以是说不同步,在多线程的形式是不安全的.
三.字段
transient Object[] elements;
存储元素的数组
transient int head;
队列头位置
transient int tail;
队列尾位置
private static final int MIN_INITIAL_CAPACITY = 8;
一个新创建的队列的最小容量
四.构造函数
4.1 无参的构造方法,创建一个容量为16的ArrayDeque
源码如下:
public ArrayDeque() { //无参构造函数,默认的底层数组大小为16.
elements = new Object[16];
}
4.2 有参的构造方法,创建一个指定大小的ArrayDeque
源码如下:
public ArrayDeque(int numElements) { //如果指定初始容量小于8,将会返回容量为8的新数组。
allocateElements(numElements); //调用allocateElements方法,分配新数组
}
private void allocateElements(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
//做移位与运算最后加一得到比给定长度大的最小的2的幂数。
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
}
elements = new Object[initialCapacity];
}
源码分析:对于一个给定长度,先判断是否小于定义的最小长度,如果小于,则使用定义的最小长度作为数组的长度。否则,找到比给定长度大的最小的2的幂数(在if里面的语句实现这一功能)。
如下图所示:
【注】 ">>>"表示无符号右移,也叫逻辑右移。即若该数为正,则高位补0,若该数为负数,则右移后高位同样补0.
4.3 有参的构造方法,将现有集合元素C加入队列进行构造
源码如下:
public ArrayDeque(Collection<? extends E> c) {
allocateElements(c.size());//调用上述allocateElements()方法,分配型数组内存空间。
addAll(c);//调用addAll()方法,将现有集合元素c添加到ArrayDeque中。
}
//addAll(Collection c) inherited from AbstractCollection
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
//将集合元素添加到ArrayDeque末尾
public boolean add(E e) {
addLast(e);//addLast()方法作用为:在最后一个元素后面添加元素。详见下述public void addLast(E e)。
return true;
}
源码分析: 先根据已有集合c大小,通过allocateElement()方法创建最小的2的幂数的数组空间。addAll()将c中元素通过add()逐个添加到型数组中。
五.方法分析
添加元素
public void addFirst(E e)
作用:在ArrayDeque前面添加元素。
源码如下:
public void addFirst(E e) {
if (e == null)
throw new NullPointerException();
elements[head = (head - 1) & (elements.length - 1)] = e;//将元素e添加到ArrayDeque双端队列的队首位置。
if (head == tail)//(head == tail)判定内存不足
doubleCapacity();//进行扩容操作
}
//扩容为原来的两倍
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;
}
//java.lang.System
/*
@Function:复制数组,以插入元素,但是要将index之后的元素都往后移一位。然后就是插入元素,增加sized的值
@src:源数组 srcPos:源数组要复制的起始位置 dest:目的数组 destPos:目的数组放置的起始位置 length:复制的长度
*/
public static native void arraycopy(Object src,int srcPos,Object dest, int destPosint length);
源码分析:将元素插入到head前一位,同时修改head值。判断内存是否足够,若不够,扩容为原数组的两倍。然后通过System.arraycopy(),将原来数组的元素复制到新数组中。
elements[head = (head - 1) & (elements.length - 1)] = e;
当head ≠ 0时
因为element数组的内存大小为2的n次幂,因此(elements.length-1),二进制为全1,[head - 1] & (elements.length - 1)]值始终为head-1的值。即在element[head-1]插入元素。当head = 0时
head - 1 = -1。其中-1用二进制表示为全1,与elements.length - 1逐位与,结果为elements.length - 1的值,即在数组的末尾插入元素。System.arraycopy(elements, p, a, 0, r);
System.arraycopy(elements, 0, a, r, p);
将elements数组从head索引(n-p)长度复制到a数组从0开始的位置。然后将elements数组从0索引开始p长度复制到a数组r索引开始的位置。
如下图所示:
public void addLast(E e)
作用:在ArrayDeque后面添加元素。
源码如下:
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
elements[tail] = e;//将e放到tail位置
if ( (tail = (tail + 1) & (elements.length - 1)) == head)//和head的操作类似,为了处理临界情况 (tail为length - 1时),和length - 1进行与操作,结果为0
doubleCapacity();//将ArrayDeque容量扩展为原来的两倍。源码详见上述public void addFirst(E e)
}
源码分析: 在ArrayDeque中tail索引处添加元素e。若添加元素后tail+1 == head,判定内存不足,对ArrayDeque调用doubleCapacity()进行扩容操作。
public boolean offerFirst(E e)
作用:在ArrayDeque前添加一个元素,并返回是否添加成功。
源码如下:
public boolean offerFirst(E e) {
addFirst(e);//在ArrayDeque数组head前添加元素,addFirst()详见上述public void addFirst().
return true;
}
源码分析: 调用addFirst()方法,当添加成功后返回true。
public boolean offerLast(Object o)
作用:在ArrayDeque后面添加一个元素,并返回是否添加成功。
源码如下:
public boolean offerLast(E e) {
addLast(e);//在ArrayDeque数组tail出添加元素,addLast()详见上述public void addLast()
return true;
}
源码分析: 调用addLast()方法,当添加成功后返回true.
public E pollFirst()
作用:删除第一个元素,并返回删除元素的值。如果元素为null,将返回null.
源码如下:
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;
}
源码分析: 将数组的第一个元素赋值给result并返回,同时将head后移。
public E removeFirst()
作用:删除第一个元素,并返回删除元素的值。如果元素为null,将抛出异常。
源码如下:
public E removeFirst() {
E x = pollFirst();//将删除后的值赋给x,pollFirst()详见上述pollFirst()
if (x == null)
throw new NoSuchElementException();
return x;
}
源码分析: 调用pollFirst()返回删除的值,若返回值为null,抛出异常。
public E pollLast()
作用:删除最后一个元素,并返回删除元素的值。如果元素为null,将返回null。
源码如下:
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;
}
源码分析: (tail - 1) & (elements.length - 1)指定待删除元素的位置,并将待删除元素赋值给result.同时将数组中最后一个元素赋null值。
public E removeLast()
作用:删除最后一个元素,并返回删除元素的值。如果元素为null,将抛出异常。
源码如下:
public E removeLast() {
E x = pollLast();
if (x == null)
throw new NoSuchElementException();
return x;
}
源码分析: 调用pollLast()返回删除的值,若返回值为null,抛出异常。
public boolean removeFirstOccurrence(Object o)
作用:删除第一次出现的指定元素。
源码如下:
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;
}
源码分析:
i = (i + 1) & mask;
对数组从头到尾进行遍历,
原理如下图所示:
从数组的head处对非空元素进行遍历,若数组中包含o对象,调用delete()进行删除,并返回true;否则,返回false。
private boolean delete(int i)源码如下所示:
private void checkInvariants() {//有效性检查
assert elements[tail] == null;//tail位置没有元素
assert head == tail ? elements[head] == null :
(elements[head] != null &&
elements[(tail - 1) & (elements.length - 1)] != null);//如果head和tail重叠,队列为空;否则heaed位置有元素,tail-1位置有元素
assert elements[(head - 1) & (elements.length - 1)] == null;//head-1 的位置没有元素
}
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;//i到head元素处之间的元素个数
final int back = (t - i) & mask;//i到tail元素处之间的元素个数
// Invariant: head <= i < tail mod circularity
if (front >= ((t - h) & mask))//i到head元素处的距离大于现有元素总数,抛出异常
throw new ConcurrentModificationException();
// Optimize for least element motion
if (front < back) {//i的元素靠近head,移动开始的元素,返回false.
if (h <= i) {//当i在head的后面
//将从head开始长度为front的数组片段复制到head+1开始的地方
System.arraycopy(elements, h, elements, h + 1, front);
} else { // 当i在head的前面
//将0 ~ (i - 1)的元素后移一位,将数组最后一位元素移到数组第一位,将head后的元素后移一位。
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 {//i的位置靠近tail,移动末尾的元素,返回true.
if (i < t) { 当i在tail的前面
//将从i + 1开始长度为back的数组片段复制到以i开始的地方
System.arraycopy(elements, i + 1, elements, i, back);
tail = t - 1;
} else { //当i在tail后面
//将从i+1到数组最后一个元素往前移动一位,再将第一个元素移到最后一位。将剩余元素往前移动一位
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;
}
}
源码分析: 为了算法的复杂度,将delete()函数分为三种情况
如下图所示:
一.待删除元素距离第一个元素比最后一个元素近
1.1 待删除元素在数组中的位置在第一个元素的后面
将从head开始长度为front的数组片段复制到head+1开始的地方。如下图所示:1.2 待删除元素在数组中的位置在第一个元素的前面
将0 ~ (i - 1)的元素后移一位,将数组最后一位元素移到数组第一位,将head后的元素后移一位。如下图所示:二.待删除元素距离最后一个元素比第一个元素近
2.1 待删除元素在数组中的位置在第一个元素的前面
将从i + 1开始长度为back的数组片段复制到以i开始的地方。如下图所示:2.2 待删除元素在数组中的位置在第一个元素的后面
将从i+1到数组最后一个元素往前移动一位,再将第一个元素移到最后一位。将剩余元素往前移动一位。如下图所示:三.待删除元素到第一个元素的距离等于到最后一个元素的距离
同情况二。public boolean removeLastOccurrence(Object o)
作用:删除最后一次出现的指定元素。
源码如下:
public boolean removeLastOccurrence(Object o) {
if (o == null)
return false;
int mask = elements.length - 1;
int i = (tail - 1) & mask;
Object x;
while ( (x = elements[i]) != null) {
if (o.equals(x)) {
delete(i);
return true;
}
i = (i - 1) & mask;//从尾到头遍历
}
return false;
}
源码分析: 从最后一个元素处对数组进行遍历,若数组中包含o对象,调用delete()进行删除,并返回true;否则,返回false。原理同上述public boolean removeFirstOccurrence(Object o)。
public E getFirst()
作用:获取第一个元素,如果没有将抛出异常。
源码如下:
public E getFirst() {
@SuppressWarnings("unchecked")
E result = (E) elements[head];
if (result == null)
throw new NoSuchElementException();
return result;
}
源码分析: 将head索引处元素值返回。
public E getLast()
作用:获取最后一个元素,如果没有将抛出异常。
源码如下:
public E getLast() {
@SuppressWarnings("unchecked")
E result = (E) elements[(tail - 1) & (elements.length - 1)];
if (result == null)
throw new NoSuchElementException();
return result;
}
源码分析: 将最后一个元素值返回。
public boolean add(E e)
作用:在队列尾部添加一个元素。
源码如下:
public boolean add(E e) {
addLast(e);//addLast()方法作用为:在最后一个元素后面添加元素。详见下述public void addLast(E e)。
return true;
}
public boolean offer(E e)
作用:在队列尾部添加一个元素,并返回是否成功
源码如下:
public boolean offer(E e) {
return offerLast(e);//offerLast()源码分析详见上述public boolean offerLast(Object o)
}
public E remove()
作用:删除队列中第一个元素,并返回该元素的值,如果元素为null,将抛出异常(其实底层调用的是removeFirst())
源码如下:
public E remove() {
return removeFirst();//移除队列第一个元素。removeFirst()源码分析详见上述:public E removeFirst()
}
public E poll()
作用:删除队列中第一个元素,并返回该元素的值,如果元素为null,将返回null。
源码如下:
public E poll() {
return pollFirst();//删除第一个元素,并返回删除元素的值.pollFirst()源码分析详见上述public E pollFirst()
}
public E element()
作用:获取第一个元素。如果没有将抛出异常
源码如下:
public E element() {
return getFirst();//getFirst()用于获取第一个元素, 源码详见上述: public E getFirst()
}
public E peek()
作用:获取第一个元素,如果返回null.
源码如下:
public E peek() {
return peekFirst();
}
public E peekFirst() {
// elements[head] is null if deque empty
return (E) elements[head];
}
public void push(E e)
作用:栈顶添加一个元素.
源码如下:
public void push(E e) {
addFirst(e);//在head索引前添加元素,并将head前移。源码分析详见上述:public void addFirst(E e)
}
public E pop()
作用:栈顶添加一个元素.
源码如下:
public E pop() {
return removeFirst();//删除第一个元素,并返回删除元素的值。源码分析详见上述:public E removeFirst()
}
public int size()
作用:获取队列中元素个数.
源码如下:
public int size() {
return (tail - head) & (elements.length - 1);
}
源码分析: 当tail在数组中的位置在head的后面(tail - head) & (elements.length - 1) 等价于 (tail - head)。当tail在数组中的位置在head的前面(tail - head) & (elements.length - 1) 等价于 elements - (tail - head)。
public boolean isEmpty()
作用:判断队列是否为空。
源码如下:
public boolean isEmpty() {
return head == tail;
}
源码分析: tail位置的元素一定为空,head和tail相等,也为空。
public Iterator iterator()
作用:迭代器,从前往后迭代
源码如下:
public Iterator<E> iterator() {
return new DeqIterator();
}
private class DeqIterator implements Iterator<E> {
private int cursor = head;
private int fence = tail; // 迭代终止索引,同时也为了检测并发修改。
private int lastRet = -1; // 最近的next()调用返回的索引。据此可以定位到需要删除元素的位置。
public boolean hasNext() {
return cursor != fence;
}
public E next() {
if (cursor == fence)
throw new NoSuchElementException();
E result = elements[cursor];
// This check doesn't catch all possible comodifications,
// but does catch the ones that corrupt traversal
if (tail != fence || result == null)
throw new ConcurrentModificationException();
lastRet = cursor;
cursor = (cursor + 1) & (elements.length - 1); // 游标位置加1
return result;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
if (delete(lastRet)) { // 如果将元素从右往左移,需要将游标减1。
cursor = (cursor - 1) & (elements.length - 1); // 游标位置回退1。
fence = tail; // 重置阀值。
}
lastRet = -1;
}
}
源码分析: ArrayDeque继承了Iterable接口,必须实现其中的iterator(),ArrayDeque实现从头往后遍历的迭代器iterator(),其中主要包含:hasNext()方法用于判定当前cursor是否还有下一个元素;next()方法来锁定下一个元素;以及remove()用于移除lastRet处的元素值。
public Iterator descendingIterator()
作用:迭代器,从后向前迭代
源码如下:
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
private class DescendingIterator implements Iterator<E> {
private int cursor = tail; // 游标开始索引为tail
private int fence = head; // 游标的阀值为head
private int lastRet = -1;
public boolean hasNext() {
return cursor != fence;
}
public E next() {
if (cursor == fence)
throw new NoSuchElementException();
cursor = (cursor - 1) & (elements.length - 1); // tail是下个添加元素的位置,所以要减1才是尾节点的索引。
E result = elements[cursor];
if (head != fence || result == null)
throw new ConcurrentModificationException();
lastRet = cursor;
return result;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
if (!delete(lastRet)) { // 如果从左往右移,需要将游标加1。
cursor = (cursor + 1) & (elements.length - 1);
fence = head;
}
lastRet = -1;
}
}
源码分析: DescendingIterator是从后往前的迭代器。其中主要包含:hasNext()方法用于判定当前cursor是否还有下一个元素;next()方法来锁定下一个元素;以及remove()用于移除lastRet处的元素值。
public boolean contains(Object o)
作用:判断队列中是否存在钙元素。
源码如下:
public boolean contains(Object o) {
if (o == null)
return false;//ArrayDeque不能存储null值
int mask = elements.length - 1;
int i = head;
Object x;
while ( (x = elements[i]) != null) {
if (o.equals(x))
return true;
i = (i + 1) & mask;//处理临界情况
}
return false;
}
源码分析: 同上述:public boolean removeFirstOccurrence(Object o),从前往后遍历,如果在数组中存在与o相同的元素,则返回true。否则,返回false。
public Object[] toArray()
作用:转成数组。
源码如下:
public Object[] toArray() {
return copyElements(new Object[size()]);
}
private <T> T[] copyElements(T[] a) {
if (head < tail) {//将elements数组所有元素复制到从0索引开始的a数组中
System.arraycopy(elements, head, a, 0, size());
} else if (head > tail) {//先复制从elements数组head~elements.length - 1处数组,然后将0 ~ tail - 1索引处元素复制到后面
int headPortionLen = elements.length - head;
System.arraycopy(elements, head, a, 0, headPortionLen);
System.arraycopy(elements, 0, a, headPortionLen, tail);
}
return a;
}
源码分析: 把所有元素拷贝到新创建的Object数组上,所以对返回数组的修改不会影响该双端队列。
public T[] toArray(T[] a)
作用:转成指定数组。
源码如下:
public <T> T[] toArray(T[] a) {
int size = size();
if (a.length < size)//目标数组大小不够
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);//利用反射创建类型为T,大小为size的数组
copyElements(a);//拷贝所有元素到目标数组。源码详见上述:>public Object[] toArray()
if (a.length > size)
a[size] = null;//结束标识
return a;
}
源码分析:
a = (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
public void clear()
作用:清空队列。
源码如下:
public void clear() {
int h = head;
int t = tail;
if (h != t) { // 判空条件
head = tail = 0;
int i = h;
int mask = elements.length - 1;
do {
elements[i] = null;//清除元素
i = (i + 1) & mask;
} while (i != t);
}
}
源码分析: 从前往后将数组值置空值。
public ArrayDeque clone()
作用:克隆(复制)一个新的队列。
源码如下:
public ArrayDeque<E> clone() {
try {
@SuppressWarnings("unchecked")
ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
//传入elements数组与数组长度返回一个新数组。
result.elements = Arrays.copyOf(elements, elements.length);//深度复制
return result;
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}