编程语言
首页 > 编程语言> > 带你从头看完java集合框架源码之Queue

带你从头看完java集合框架源码之Queue

作者:互联网

带你从头看完java集合框架源码之Queue

目录

  1. java集合框架源码之总体预览
  2. java集合框架源码之List
  3. java集合框架源码之Queue

上一篇文章我们介绍了List接口的实现类,这一篇我们来看Queue下的各种接口以及类

接口Deque(双端队列)

方法:基本上就是在Queue的基础上,增加了一些双端队列的特性,两头存取,我们可以看到基本每种操作都有两种形式(从头,或从尾)

//添加元素(头、尾),失败抛IllegalStateException异常
void addFirst(E e);
void addLast(E e);

//添加元素(头、尾),与add的区别是,失败返回false,不会抛异常
boolean offerFirst(E e);
boolean offerLast(E e);

//返回并删除元素(头、尾),失败抛NoSuchElementException异常
E removeFirst();
E removeLast();

//返回并删除元素(头、尾),队列为空时返回null
E pollFirst();
E pollLast();

//返回元素但不删除(头、尾),队列空时抛NoSuchElementException异常
E getFirst();
E getLast();

//返回元素但不删除(头、尾),队列空时返回null
E peekFirst();
E peekLast();

//删除第一次出现的指定元素(从头遍历和从尾遍历)
boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);

从接口中方法的说明可以看出,如果实现类是大小受限的Deque,在修改队列时应该调用offer、poll、peek这些失败不会抛异常的方法。如果实现类容量不受限制,则应该调用add、remove、get这些方法

往下,有一个实现了Queue接口的抽象类AbstractQueue

类AbstractQueue:

同样,这个抽象类提供了Queue接口的最小实现。如果不允许添加nul元素时,抽象类的实现就是合适的。如果有其他需要,则应该继承抽象类,对方法进行重写

public abstract class AbstractQueue<E>
    extends AbstractCollection<E>
    implements Queue<E> 

add方法、remove方法element方法调用了offer、poll和peek(继承与Queue),会抛出异常

接下来是Queue的两个实现类,ArrayDeque、PriorityQueue

类ArrayDeque:

特点:数组实现的双向循环队列,没有容量限制可以动态扩容,线程不安全,不允许添加NULL

This class is likely to be faster than {@link Stack} when used as a stack, and faster than {@link LinkedList} when used as a queue.

注释里有这么一段话,该类用做堆栈或者队列时,可能比Stack和LinkedList块,比Stack快是因为Stack的方法都用synchronized进行了同步,会产生开销

而比LinkedList快,是因为LinkedList是链表实现,而ArrayDeque是数组实现,链表在查找时是O(n)的时间复杂度,数组是O(1),这个是查找时的时间复杂度差距。至于在头尾添加元素,两个实现类都是O(1)的时间复杂度,但是由于LinkedList是链表实现,每次添加时需要new结点,new一个对象的开销是比较大的,而数组则不需要。

实际测试下,1000万添加,大概快个7倍左右

public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            linkedList.add("1234");
        }
        long end = System.currentTimeMillis();
        System.out.println("LinkedList" +"  "+ (end - start));
        ArrayDeque<String> arrayDeque = new ArrayDeque<>();

        start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            arrayDeque.add("1234");
        }
        end = System.currentTimeMillis();

        System.out.println("ArrayDeque" +"  " + (end - start));
    }
输出:LinkedList  2313
	ArrayDeque  313
//继承的和实现的基本都是老熟人了
public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable

看看成员变量

//元素数组
transient Object[] elements;
//头指针
transient int head;
//尾指针
transient int tail;
//最小初始化容量8,且容量必须是2的倍数,为啥呢?后边说
private static final int MIN_INITIAL_CAPACITY = 8;

往下,分析构造方法

//无参构造方法,默认初始容量16
public ArrayDeque() {
        elements = new Object[16];
    }
//有参构造,指定容量,调用allocateElements
public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }
//有参构造,传入一个集合,调用allocateElements确认容量,调用addAll方法添加元素
public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }

看看确定容量的allocateElements方法

private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
    }

调用了calculateSize,接着看:

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;
    }

这段代码是找到一个值,他的大小是大于8和numElements且最接近numElements的2的方幂。也就是8<2^n && numElements<2^n

很多人看到中间一连串|=就蒙了,我也是,查了一下资料后才理解为什么这样操作可以获得比numElements大且最接近numElements的2^n。原理是这样的,看下面这张图,来源(https://www.imooc.com/article/75047)

初始值是89,图中对应的是二进制01011001,这时候我们想找比89大的最小2的方幂,这个值我们都知道是10000000(二进制),就是把01011001中1的最高位

左移,然后剩下的变成0就可以了,怎么通过位运算来完成这件事呢?我们可以把10000000 看做 01111111 + 00000001,也就是说把最高位的1之后的所有位都变成1,最后再+1,就可以得到这个值,那么问题又来了,怎么把所有位变成1呢?

这时,我们可以关注从右往左的任意一个为1的值,假设是第n位。令他右移一位,然后和原来的值或,这样,得到的值中,第n位和第n - 1位就都为1了,这样我们就得到了两个1

之后,因为第n和n - 1位都是1,我们右移两位,和原来的值或,得到的值中,除了n和n - 1外,第n - 2和n - 3位也是1了。是不是有点感觉了?java中int是32位,所以只需要右移1、2、4、8、16位,每次都和移位前的值或一次,就可以把最高位之后的所有位都变成1,之后+1,就可以得到最接近numElements的2^n

我们用50来推演一遍,50的二进制是0011 0010(省略前24位为0的值,这里只看8位),按照前面解释的,任意找一个为1的位观察,这里我们挑第二位(从右往左)

先右移一位,得到0001 1001,和0011 0010或,得到0011 1011,现在可以看到,第2(n)位和第1(n - 1)位都是1了

然后右移两位,得到000 1110,和0011 1011或,得到0011 1111

然后右移四位,得到0000 0011,和0011 1111或,得到0011 1111,从这里就已经可以看到,1的最高位之后的所有位已经都是1了

之后8...16,都是同样的效果

方法最后是判断是不是溢出了,如果溢出了直接返回最大值2^30次方

看一看扩容方法,容量不足是扩大两倍

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;
    }

前面讲过容量必须是2的倍数,扩容也是两倍扩容,确定容量大小也是二的倍数,这是为什么呢?我们来看看addFirst/addLast方法

public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        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();
    }
//add调用的是addLast方法,add默认插到队尾
public boolean add(E e) {
        addLast(e);
        return true;
    }

ArrayDeque是个循环双端队列,容量是二的倍数是为了取模方便,容量是二的倍数,减一之后就成了掩码,当head = length时,和length - 1与,就变成了0,当head = -1时(补码表示为全1),和length - 1与,就变成了length - 1,达到循环的效果。当head != length - 1时,和length - 1与还是保持原来的值(因为2^n的二进制是最高位为1,后边全是0,减一后,除了原最高位外,剩余位全是1,任意值和这个值与,在没有溢出时可以起到保留原来位的效果,溢出时则得到0)

后面的方法,addFirst/Last、getFirst/Last等等基本上和介绍Queue接口的差不多,都是在相互调用

为啥要设置那么多方法呢?其实主要是为了模拟不同的数据结构,如栈操作:pop,push,peek,队列操作:add,offer,remove,poll,peek,element,双端队列操作:addFirst,addLast,getFirst,getLast,peekFirst,peekLast,removeFirst,removeLast,pollFirst,pollLast。不过确实稍微多了一点。(引用自(https://www.imooc.com/article/75047))

最后看一眼迭代器,和其他集合类不同的是,ArrayDeque没有使用modcount来实现fail-fast机制,而是在next方法中使用这样一个判断

if (tail != fence || result == null)
                throw new ConcurrentModificationException();

就是检查标记的尾指针fence和当前尾指针tail是否一致或者当前获取的元素是不是空,这种检查是偏弱的,例如我先移除一个元素再添加一个元素,这时tail指针的值还是没变,但是集合结构已经被我修改过了,这样就没办法检测出并发修改异常了

类PriorityQueue:

看Queue接口下最后一个实现类了

特点:基于优先级的队列,底层数据结构是数组实现的二叉小顶堆(每一个非叶子节点都小于他的左右节点,可以用完全二叉树表示),存放进去的元素基于构造时提供的Comparator排序或基于自然排序,不允许存放null且存放进去的元素要可排序,该类线程不安全。

二叉树的数组表示法如下:

当前结点:index

当前结点的左结点:(index * 2 + 1)

当前结点的右节点:(index * 2 + 2)

当前结点的父结点:(index - 1)/ 2

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable

看一看成员变量

//序列化ID
private static final long serialVersionUID = -7720805057305804111L;
//默认容量大小
private static final int DEFAULT_INITIAL_CAPACITY = 11;
//存放元素的数组
transient Object[] queue;
//元素个数
private int size = 0;
//比较器
private final Comparator<? super E> comparator;
//修改结构的次数
transient int modCount = 0;

构造方法:有点多,一个一个分析

//无参构造,调用另一个构造方法public PriorityQueue(int initialCapacity,Comparator<? super E> comparator)
public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }
//根据容量构造,同样调用另一个构造方法public PriorityQueue(int initialCapacity,Comparator<? super E> comparator)
public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
    }
//构造一个默认容量指定比较器的队列
public PriorityQueue(Comparator<? super E> comparator) {
        this(DEFAULT_INITIAL_CAPACITY, comparator);
    }
//构造一个指定容量指定比较器的队列
public PriorityQueue(int initialCapacity,
                         Comparator<? super E> comparator) {
        // Note: This restriction of at least one is not actually needed,
        // but continues for 1.5 compatibility
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }
//根据集合构造队列
public PriorityQueue(Collection<? extends E> c) {
    	//判断c是不是排序Set的子类
        if (c instanceof SortedSet<?>) {
            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
            //获取c的比较器,调用initElementsFromCollection
            this.comparator = (Comparator<? super E>) ss.comparator();
            initElementsFromCollection(ss);
        }
    	//否则判断是不是PriorityQueue的子类
        else if (c instanceof PriorityQueue<?>) {
            PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
            //获取比较器,调用initFromPriorityQueue
            this.comparator = (Comparator<? super E>) pq.comparator();
            initFromPriorityQueue(pq);
        }
        else {
            //否则比较器为空,调用initFromCollection
            this.comparator = null;
            initFromCollection(c);
        }
    }
//这个和上面PriorityQueue的情况一样
public PriorityQueue(PriorityQueue<? extends E> c) {
        this.comparator = (Comparator<? super E>) c.comparator();
        initFromPriorityQueue(c);
    }
//这个和上面SortedSet的情况一样
public PriorityQueue(SortedSet<? extends E> c) {
        this.comparator = (Comparator<? super E>) c.comparator();
        initElementsFromCollection(c);
    }

构造方法中调用了initElementsFromCollection、initFromPriorityQueue和initFromCollection初始化方法,我们来看这几个方法

//这个方法就是拷贝数组,然后判断是否有空元素
private void initElementsFromCollection(Collection<? extends E> c) {
        Object[] a = c.toArray();
        // If c.toArray incorrectly doesn't return Object[], copy it.
        if (a.getClass() != Object[].class)
            a = Arrays.copyOf(a, a.length, Object[].class);
        int len = a.length;
        if (len == 1 || this.comparator != null)
            for (int i = 0; i < len; i++)
                if (a[i] == null)
                    throw new NullPointerException();
        this.queue = a;
        this.size = a.length;
    }
//判断是不是PriorityQueue集合,不是的话调用initFromCollection
private void initFromPriorityQueue(PriorityQueue<? extends E> c) {
        if (c.getClass() == PriorityQueue.class) {
            this.queue = c.toArray();
            this.size = c.size();
        } else {
            initFromCollection(c);
        }
    }
//先调用initElementsFromCollection拷贝数组,然后调用heapify调整堆的顺序
private void initFromCollection(Collection<? extends E> c) {
        initElementsFromCollection(c);
        heapify();
    }

这里调用了heapify调整堆成为二叉小顶堆,我们看看是如何调整的

private void heapify() {
        for (int i = (size >>> 1) - 1; i >= 0; i--)
            siftDown(i, (E) queue[i]);
    }

可以看到对每个非叶子结点调用了siftDown方法,我们看看siftDown

private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }

根据有没有比较器分别调用siftDownUsingComparator和siftDownComparable,这两个方法只是使用的比较器不同而已,如果队列没有指定比较器则使用元素的比较器,逻辑上没有区别,我们看其中一个siftDownComparable就好

private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
    	//求当前最后一个非叶子结点的下标 + 1
        int half = size >>> 1;        // loop while a non-leaf
    	//调整的结点是非叶子结点时
        while (k < half) {
            //获得该结点左节点的下标
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            //获得该结点右节点的下标
            int right = child + 1;
            //比较左右结点哪个比较小,然后跟x结点比较
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                //c是临时变量,保存左右结点中最小的那个
                c = queue[child = right];
            //如果x结点比左右都小,则不需要调整
            if (key.compareTo((E) c) <= 0)
                break;
            //否则x结点和左右结点中最小的那个互换,然后调整那个被换的结点
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }

往下,看一下扩容的grow方法

private void grow(int minCapacity) {
        int oldCapacity = queue.length;
        // Double size if small; else grow by 50%
    	//扩容的规则,如果当前大小小于64,则新容量 = 旧容量 + 2;否则,新容量 = 旧容量 * 1.5
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // overflow-conscious code
    	//判断溢出
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        queue = Arrays.copyOf(queue, newCapacity);
    }

判断溢出的方法也是老方法了,这里就不再赘述

接下来是添加元素的方法,add调用的是offer,我们看offer

public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;
        int i = size;
    	//容量不够,扩容
        if (i >= queue.length)
            grow(i + 1);
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            //插入并从下往上调整
            siftUp(i, e);
        return true;
    }

因为小顶堆的排序,插入元素有可能会破坏排序,所以每次插入都需要调整,看看siftUp方法

private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

同样的也是根据比较器调用不同的方法,我们看其中一个就好

private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            //找到要插入节点的父节点
            int parent = (k - 1) >>> 1; 
            Object e = queue[parent];
            //不会破坏排序,不需要调整
            if (comparator.compare(x, (E) e) >= 0)
                break;
            //否则互换父节点和子节点
            queue[k] = e;
            //向上调整
            k = parent;
        }
        queue[k] = x;
    }

这个调整可以看这张图,插入是从下往上调整小顶堆

接下来看移除的方法,remove调用了removeAt

private E removeAt(int i) {
        // assert i >= 0 && i < size;
        modCount++;
        int s = --size;
        if (s == i) // removed last element
            queue[i] = null;
        else {
            //获取当前最后一个结点
            E moved = (E) queue[s];
            queue[s] = null;
            //直接把要移除的结点换成队列最后的结点,然后该顶点的堆进行调整
            siftDown(i, moved);
            //这里是一个判断,判断刚刚换过去的那个结点是不是就是这个堆的堆顶,如果是的话,有可能破坏了上层的排序,要进行向上调整
            if (queue[i] == moved) {
                //向上调整
                siftUp(i, moved);
                if (queue[i] != moved)
                    return moved;
            }
        }
        return null;
    }

poll方法和removeAt方法类似,但是他移除的是堆顶,所以和最后一个元素互换之后,只需要从上往下调整

至此,PriorityQueue类就看完了,Queue接口结束

标签:PriorityQueue,java,comparator,int,queue,initialCapacity,Queue,源码,public
来源: https://www.cnblogs.com/ForYou-Z/p/14508769.html