ArrayDeque集合源码分析

文章目录

ArrayDeque集合源码分析
一、字段分析
二、构造函数分析
方法、方法分析
四、总结

在这里插入图片描述

实现了 Deque，说面该数据结构一定是个双端队列，我们知道 LinkedList 也是双端队列，并且是用双向链表 存储结构的。而 ArrayDeque 则是使用 环形数组 来实现双端队列。各有优缺点。
实现代码比较少，难点在于使用了很多位运算进行了优化，来学习下ArrayDueue如何使用位运算代替运算符的从而实现优化的。

一、字段分析

//用来存储元素的数组，这个数组可循环利用，有效数据范围为 [head, tail）注意tail 取不到
//也会出现tail < head 的情况，即前面的数据被废弃了，且tail到已经过了数组尾部了，然后跳到开始位置
//开始循环利用前面废弃的位置。
transient Object[] elements;
//指向头部有效数据
transient int head;
//指向尾部有效数据 + 1，或者理解为下一个添加元素的位置。整个过程，head 和 tail 都是不断变化的，head ~ tail - 1 范围内为有效数据。
//并不是tail 到达数组尾部即 elements.lengt - 1 就会扩容的。因为他可能复用前面可能发生废弃数组位置。
transient int tail;
//默认初始容量
private static final int MIN_INITIAL_CAPACITY = 8;

二、构造函数分析

//调用无参构造函数，直接创建一个容量为 16 的数组作为初始数组。
public ArrayDeque() {elements = new Object[16];}//给定初始容量构建ArrayDeque，但并不是给 numElements 值为多少，就会创建多大的数组作为初始数组。
//给是判断并计算 最接近numElements的值，且为 2的幂次方的数作为初始容量。
public ArrayDeque(int numElements) {//分配容量allocateElements(numElements);}private void allocateElements(int numElements) {//确定初始容量并构建数组，赋值给实际存储元素的 elements 数组elements = new Object[calculateSize(numElements)];}//用来计算最终的容量的，计算结果为最接近 numElements 的数，且为 2的幂次方。
//比如 numElements = 15，则计算结果为 16（2^4）
//那么为什么一定要为 2的幂次方呢？为了在做取余运算时用位运算代替运算符运算，从而提高效率。
private static int calculateSize(int numElements) {//拿到默认最小的初始值，值为8int initialCapacity = MIN_INITIAL_CAPACITY;// Find the best power of two to hold elements.// Tests "<=" because arrays aren't kept full.//传入的 参数 numElements 比默认最小值还小，则直接使用默认的最小值为初始容量。，否则进行//计算，得到最接近 numElements ，且为 2 的次方的数。if (numElements >= initialCapacity) {initialCapacity = numElements;//为什么这样的计算能够得到 最接近 numElements ，且为 2 的幂次方的数呢？//首先列举下2的幂次方的二进制表示，来看下规律//0001  ： 2^0//0010  :  2^1//0100	： 2^3//1000  ： 2^4//上面例子可以看出，如果想要是 2的幂次方，那么整个二进制表示只能有一个1，其他的//1应该被消除，如果数中有不止一个1，那么最接近的应该是最高位的1前进一位，//且其他未都是0，该数就是最接近，且为2的幂次方。   //消除1的方法有所有位 都为1 在 + 1，则得到结果就有一个1，//如0111 + 1 =》 1000//我们知道一个数的最高位那一定是1了，其他位可能有1或0，而这个算法就是将其位//全部转化为1,之后再 + 1就是答案。//我们知道 Integer一共是4个字节，即32 位。//如果极限状态第31位是1（32位为1位负数，不会走当前逻辑，会给默认的最小初始容量）//我们需要将31位右边所有位都转化为1，我换一种说话，将右边连续的三十一位都转化为1。//将右边连续的2位转化为1initialCapacity |= (initialCapacity >>>  1);//将右边连续的4位转化为1initialCapacity |= (initialCapacity >>>  2);//将右边连续的8位转化为1initialCapacity |= (initialCapacity >>>  4);//将右边连续的16位转化为1initialCapacity |= (initialCapacity >>>  8);//将右边连续的32位转化为1，都能将连续的32位都转为1，你少于32的难道还不能转化为1吗。initialCapacity |= (initialCapacity >>> 16);//都转为1的基础上+1，就得到大于且最接近当前数，且为2的幂次方的数。initialCapacity++;//可能计算结果为负数，比如第31位为1，计算后变成最后一位（即符号位）变为1，成了负数//所以Good luck allocating 2 ^ 30 elements 注释也给出了我们最大容量就是2^30if (initialCapacity < 0)   // Too many elements, must back offinitialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements}return initialCapacity;}public ArrayDeque(Collection<? extends E> c) {//判断是否需要扩容allocateElements(c.size());//将集合c中所有元素添加到ArrayDeque中addAll(c);}//将集合c中所有元素添加到ArrayDeque中
public boolean addAll(Collection<? extends E> c) {boolean modified = false;//循环遍历添加集合c中的元素for (E e : c)if (add(e))modified = true;return modified;}//添加元素e
public boolean add(E e) {//添加元素到尾部addLast(e);return true;}//添加元素到尾部，即tail位置
public void addLast(E e) {if (e == null)throw new NullPointerException();//呼应我前面介绍tail的，tail 为下一个添加元素的位置，所以直接在该位置添加。 elements[tail] = e;//判断队列是否已满了，其实效果就是 tail + 1 后是否和 head 重合，即 tail + 1 == head ???//如何理解这段代码呢，就要结合我上面说的 为什么 elements 的数组长度设计为 2的幂次方有关了！！//正因为 elements.length 是2的幂次方，那么它 - 1 后二进制的最高位（该位置记为@）由 1 -> 0,而所有的低位变为1//在和tail 做 & 运算时，就会将tail二进制 @ 位及更高位全部转化为0，而@后面的全部转化为1，//相当于 tail % elements 做取余运算。//所以将elements.length设为2的幂次方好处就是：在判断tail 与 head 的关系是，//可用二进制运算取余代替 运算符取余运算，提高效率。//name 有一个疑问了，为什么不直接用 tail + 1 == head ？ 不就行了吗？？算都不用算不是更快吗？？//因为要考虑越界的情况！！elements 是一个可循环使用的环形数组，比如 tail = elements.lenth - 1，tail + 1后越界了//所以要做 & 运算！！if ( (tail = (tail + 1) & (elements.length - 1)) == head)//tail 与 head重合，需要扩容了doubleCapacity();}private void doubleCapacity() {//断言， head ！= tail 就会抛出异常。也可体现出，ArrayDequeue 当 head == tail 时，进行扩容。 assert head == tail;//记录头结点int p = head;//当前数组容量int n = elements.length;//head 到 elements.length - 1 ，共有多少元素 (p,elements.length - 1]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];//相当于将 老数组 head 到 数组末尾的数据，复制到新数组中，复制到新数组下标0开始位置，长度就是r//你可以理解为head位起始位置，从head一直复制到tail，依次复制给新数组，从0 开始的位置。System.arraycopy(elements, p, a, 0, r);//将老数组o 位置开始以此复制给新数组。//这两部给个过程就明白了//				// 1. element[0, 1, 2, 3, 4, 5]   => newElements[3,4,5,0,0,0,0,0,0,0];//                 head// 2. element[0, 1, 2, 3, 4, 5]   => newElements[3,4,5,0,1,2,0,0,0,0];//                 headSystem.arraycopy(elements, 0, a, r, p);//elements 指向新的数组elements = a;//head 指向索引 0head = 0;//tail 指向最后一个位置的下一位，即下一个添加进ArrayDequeue元素的位置。tail = n;}

方法、方法分析

添加元素方法。


//添加元素到尾部，即tail位置
public void addLast(E e) {if (e == null)throw new NullPointerException();//呼应我前面介绍tail的，tail 为下一个添加元素的位置，所以直接在该位置添加。 elements[tail] = e;//判断队列是否已满了，其实效果就是 tail + 1 后是否和 head 重合，即 tail + 1 == head ???//如何理解这段代码呢，就要结合我上面说的 为什么 elements 的数组长度设计为 2的幂次方有关了！！//正因为 elements.length 是2的幂次方，那么它 - 1 后二进制的最高位（该位置记为@）由 1 -> 0,而所有的低位变为1//在和tail 做 & 运算时，就会将tail二进制 @ 位及更高位全部转化为0，而@后面的全部转化为1，//相当于 tail % elements 做取余运算。//所以将elements.length设为2的幂次方一个好处就是：在判断tail 与 head 的关系是，//可用二进制运算取余代替 运算符取余运算，提高效率。//name 有一个疑问了，为什么不直接用 tail + 1 == head ？ 不就行了吗？？算都不用算不是更快吗？？//因为要考虑越界的情况！！elements 是一个可循环使用的环形数组，比如 tail = elements.lenth - 1，tail + 1后越界了//所以要做 & 运算！！if ( (tail = (tail + 1) & (elements.length - 1)) == head)//tail 与 head重合，需要扩容了doubleCapacity();}//向 head - 1 处添加元素
public void addFirst(E e) {if (e == null)throw new NullPointerException();//取余运算，同时防止了越界。将head - 1 处复制eelements[head = (head - 1) & (elements.length - 1)] = e;//判断是否扩容if (head == tail)//扩容，扩容方法看构造方法里介绍了doubleCapacity();}
//向 tail 位置添加元素
public void addLast(E e) {if (e == null)throw new NullPointerException();//直接给tail 位置赋值elements[tail] = e;//取余元素，判断是否扩容if ( (tail = (tail + 1) & (elements.length - 1)) == head)//扩容doubleCapacity();}//向 tail 处添加元素    
public boolean offerLast(E e) {addLast(e);return true;}//向 head - 1 处添加元素
public boolean offerFirst(E e) {addFirst(e);return true;}//向tail 处添加元素
public boolean add(E e) {addLast(e);return true;}
//向tail 处添加元素
public boolean offer(E e) {return offerLast(e);}
//向 head - 1处添加元素public void push(E e) {addFirst(e);}

获取元素方法。

//弹出 head 位置元素
public E pollFirst() {int h = head;@SuppressWarnings("unchecked")E result = (E) elements[h];// Element is null if deque emptyif (result == null)return null;//弹出后将head位置设为nullelements[h] = null;     // Must null out slot//获取head的下一个位置，取余运算防止越界。head = (h + 1) & (elements.length - 1);//返回结果return result;}//弹出 tail - 1 处元素
public E pollLast() {//获取元素位置，取余防止越界int t = (tail - 1) & (elements.length - 1);@SuppressWarnings("unchecked")E result = (E) elements[t];if (result == null)return null;//弹出后，该位置设为null    elements[t] = null;//新的tailtail = t;return result;}//获取head位置元素，但不弹出
public E getFirst() {@SuppressWarnings("unchecked")E result = (E) elements[head];if (result == null)throw new NoSuchElementException();return result;}//获取tail-1位置处元素，但不弹出
public E getLast() {@SuppressWarnings("unchecked")E result = (E) elements[(tail - 1) & (elements.length - 1)];if (result == null)throw new NoSuchElementException();return result;}//获取head位置元素，但不弹出
public E peekFirst() {// elements[head] is null if deque emptyreturn (E) elements[head];}//获取tail-1位置处元素，但不弹出
public E peekLast() {return (E) elements[(tail - 1) & (elements.length - 1)];}//弹出 head 位置元素
public E poll() {return pollFirst();}//获取head位置元素，但不弹出
public E element() {return getFirst();}//获取head位置元素，但不弹出
public E peek() {return peekFirst();}//弹出 head 位置元素
public E pop() {return removeFirst();}

移除元素方法：

//删除 head 处元素
public E removeFirst() {//删除 head 处元素E x = pollFirst();if (x == null)throw new NoSuchElementException();//返回被删除的元素   return x;}//删除 tail - 1 处的元素
public E removeLast() {删除 tail - 1 处的元素E x = pollLast();if (x == null)throw new NoSuchElementException();//返回被删除的元素    return x;}//删除 head 处元素
public E pollFirst() {//记录head位置int h = head;@SuppressWarnings("unchecked")//记录head处元素，用于返回E result = (E) elements[h];// Element is null if deque emptyif (result == null)return null;//将head处元素设为空    elements[h] = null;     // Must null out slot//计算新的head，取余元素防止越界head = (h + 1) & (elements.length - 1);return result;}//删除 tail - 1 处的元素
public E pollLast() {//获取 tail -1 位置下标，取余运算，防止越界int t = (tail - 1) & (elements.length - 1);@SuppressWarnings("unchecked")//获取删除元素位置E result = (E) elements[t];if (result == null)return null;//tail - 1位置被置空    elements[t] = null;//更新tail位置tail = t;return result;}//删除head处元素
public E remove() {return removeFirst();}//删除head出元素
public E poll() {return pollFirst();}//删除head处元素
public E pop() {return removeFirst();}

扩容方法：在介绍构造函数时，一并介绍了。
迭代器：

private class DeqIterator implements Iterator<E> {/*** Index of element to be returned by subsequent call to next.*///用于记录迭代得到下一个元素的下标位置。初始值当时是head了。private int cursor = head;/*** Tail recorded at construction (also in remove), to stop* iterator and also to check for comodification.*///用于记录迭代的中止位置private int fence = tail;/*** Index of element returned by most recent call to next.* Reset to -1 if element is deleted by a call to remove.*///用于记录最后一次迭代得到的元素位置，迭代还未开始，当然给-1了。private int lastRet = -1;//判断是否还有元素可以迭代public boolean hasNext() {return cursor != fence;}//迭代获取下一个元素public E next() {//无元素了，报错if (cursor == fence)throw new NoSuchElementException();@SuppressWarnings("unchecked")//获取cursor处的位置元素E result = (E) elements[cursor];// This check doesn't catch all possible comodifications,// but does catch the ones that corrupt traversal//判断迭代过程中集合是否被修改过。和 modCount作用相同if (tail != fence || result == null)throw new ConcurrentModificationException();//记录最后一次迭代得到元素的位置    lastRet = cursor;//获取下一次迭代元素位置下标，位运算，防止越界cursor = (cursor + 1) & (elements.length - 1);return result;}//迭代删除，删除的是最后以此迭代得到的元素public void remove() {//以此还被迭代呢，删除失败if (lastRet < 0)throw new IllegalStateException();//删除元素if (delete(lastRet)) { // if left-shifted, undo increment in next()cursor = (cursor - 1) & (elements.length - 1);fence = tail;}//上一次迭代的元素被删除了，所以即为-1。所以迭代过程中不能连续remove。lastRet = -1;}}