當(dāng)前位置:首頁 > IT技術(shù) > 編程語言 > 正文

Java Review - Queue和Stack 源碼解讀
2021-11-16 11:34:53

Java Review - Queue和Stack 源碼解讀_數(shù)組


Pre

Java Review - ArrayList 源碼解讀

Java Review - LinkedList源碼解讀


概述

Java中有Stack類,卻沒有叫做Queue的類,它是個接口的名字。當(dāng)需要使用棧時,Java已不推薦使用Stack,而是推薦使用更高效的ArrayDeque;

既然Queue只是一個接口,當(dāng)需要使用隊列時也就首選ArrayDeque了,次選LinkedList。

Java Review - Queue和Stack 源碼解讀_Stack_02


Queue

Java Review - Queue和Stack 源碼解讀_Queue_03

Queue接口繼承自Collection接口,除了最基本的Collection的方法之外,它還支持額外的insertion, extraction和inspection操作。

這里有兩組格式,共6個方法,

  • 一組是拋出異常的實現(xiàn);
  • 另外一組是返回值的實現(xiàn)(沒有則返回null)。
拋出異常的方法 帶有返回值的方法
Insert add(e) offer(e)
Remove remove poll()
Examine element() peek

Deque

Java Review - Queue和Stack 源碼解讀_Queue_04

  • Deque是"double ended queue", 表示雙向的隊列,英文讀作"deck".

  • Deque 繼承自 Queue接口,除了支持Queue的方法之外,還支持insert, remove和examine操作

  • 由于Deque是雙向的,所以可以對隊列的頭和尾都進(jìn)行操作 . 同時也支持兩組格式,一組是拋出異常的實現(xiàn);另外一組是返回值的實現(xiàn)(沒有則返回null)。共12個方法如下:
    Java Review - Queue和Stack 源碼解讀_拋出異常_05

  • 當(dāng)把Deque當(dāng)做FIFO的queue來使用時,元素是從deque的尾部添加,從頭部進(jìn)行刪除的; 所以deque的部分方法是和queue是等同的。如下
    -Java Review - Queue和Stack 源碼解讀_Queue_06

  • Deque的含義是“double ended queue”,即雙端隊列,它既可以當(dāng)作棧使用,也可以當(dāng)作隊列使用。下表列出了Deque與Queue相對應(yīng)的接
    Java Review - Queue和Stack 源碼解讀_java_07

  • Deque與Stack對應(yīng)的接口如下:
    Java Review - Queue和Stack 源碼解讀_Queue_08

上面兩個表共定義了Deque的12個接口。

添加,刪除,取值都有兩套接口,它們功能相同,區(qū)別是對失敗情況的處理不同。

一組接口遇到失敗就會拋出異常

另一組遇到失敗會返回特殊值(false或null)。

除非某種實現(xiàn)對容量有限制,大多數(shù)情況下,添加操作是不會失敗的。雖然Deque的接口有12個之多,但無非就是對容器的兩端進(jìn)行操作,或添加,或刪除,或查看。

Java Review - Queue和Stack 源碼解讀_java_09

ArrayDeque

Java Review - Queue和Stack 源碼解讀_拋出異常_10

一覽

ArrayDeque和LinkedList是Deque的兩個通用實現(xiàn),由于官方更推薦使用AarryDeque用作棧和隊列,著重講解ArrayDeque的具體實現(xiàn)。

  • 從名字可以看出ArrayDeque底層通過數(shù)組實現(xiàn),為了滿足可以同時在數(shù)組兩端插入或刪除元素的需求,該數(shù)組還必須是循環(huán)的,即循環(huán)數(shù)組(circular array),也就是說數(shù)組的任何一點都可能被看作起點或者終點。

  • ArrayDeque是非線程安全的(not thread-safe),當(dāng)多個線程同時使用的時候,需要手動同步;

  • ArrayDeque不允許放入null元素

Java Review - Queue和Stack 源碼解讀_java_11
上圖中我們看到,head指向首端第一個有效元素,tail指向尾端第一個可以插入元素的空位。因為是循環(huán)數(shù)組,所以head不一定總等于0,tail也不一定總是比head大.


構(gòu)造函數(shù)

Java Review - Queue和Stack 源碼解讀_拋出異常_12

/**
     * Constructs an empty array deque with an initial capacity
     * sufficient to hold 16 elements.
     */
    public ArrayDeque() {
        elements = new Object[16];
    }

    /**
     * Constructs an empty array deque with an initial capacity
     * sufficient to hold the specified number of elements.
     *
     * @param numElements  lower bound on initial capacity of the deque
     */
    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }

    /**
     * Constructs a deque containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.  (The first element returned by the collection's
     * iterator becomes the first element, or <i>front</i> of the
     * deque.)
     *
     * @param c the collection whose elements are to be placed into the deque
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }
   /**
     * Allocates empty array to hold the given number of elements.
     *
     * @param numElements  the number of elements to hold
     */
    private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
    }
    /**
     * 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;
    }

三個構(gòu)造函數(shù)

  1. 申請默認(rèn)大小為16的數(shù)組
  2. 提供需要空間大小的有參構(gòu)造器:利用allocateElements申請空間
  3. 利用現(xiàn)有集合的有參構(gòu)造器:同樣利用allocateElements申請空間,再將現(xiàn)有集合中的元素拷貝到數(shù)組中

allocateElements(int numElements) :數(shù)組最小空間為8, 如果需要空間小于8,則申請數(shù)組大小為8,如果需要空間大于等于8,進(jìn)行一定的容量擴(kuò)大,而不只是提供需要數(shù)量的空間,防止下一次操作時又要進(jìn)行擴(kuò)容


屬性

Java Review - Queue和Stack 源碼解讀_java_13

ArrayDeque提供了兩個變量來操作數(shù)組:head 、 tail.

  • head指向隊列的頭,tail指向隊列尾的下一個位置,隊列滿的條件就是head == tail.

  • 擴(kuò)容操作的執(zhí)行時機(jī):每次在向隊列中添加元素以后,不論是在頭部還是在尾部添加。

  • 擴(kuò)容策略:空間是原空間的兩倍大,將原來數(shù)組中元素拷貝到新數(shù)組中,因為是循環(huán)隊列,可能出現(xiàn)head在tail后面的情況,拷貝到新數(shù)組時,從head指向開始拷貝,直到tail,也就是說,拷貝完成后,head指向新數(shù)組起始位置,tail指向最后一個元素的下一個位置。


方法

addFirst()

    /**
     * Inserts the specified element at the front of this deque.
     *
     * @param e the element to add
     * @throws NullPointerException if the specified element is null
     */
    public void addFirst(E e) {
        if (e == null) //不允許放入null
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e; //2.下標(biāo)是否越界
        if (head == tail)//1.空間是否夠用
            doubleCapacity();//擴(kuò)容
    }

addFirst(E e)的作用是在Deque的首端插入元素,也就是在head的前面插入元素,在空間足夠且下標(biāo)沒有越界的情況下,只需要將elements[–head] = e即可 。

上述代碼我們看到,空間問題是在插入之后解決的,因為tail總是指向下一個可插入的空位,也就意味著elements數(shù)組至少有一個空位,所以插入元素的時候不用考慮空間問題。

下標(biāo)越界的處理 ,head = (head - 1) & (elements.length - 1)就可以了,這段代碼相當(dāng)于取余,同時解決了head為負(fù)值的情況。

因為elements.length必需是2的指數(shù)倍,elements - 1就是二進(jìn)制低位全1,跟head - 1相與之后就起到了取模的作用,如果head - 1為負(fù)數(shù)(其實只可能是-1),則相當(dāng)于對其取相對于elements.length的補(bǔ)碼。

接下來看擴(kuò)容的邏輯

    /**
     * Doubles the capacity of this deque.  Call only when full, i.e.,
     * when head and tail have wrapped around to become equal.
     */
    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  .head右邊元素的個數(shù)
        int newCapacity = n << 1; //原空間的2倍
        if (newCapacity < 0)
            throw new IllegalStateException("Sorry, deque too big");
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);//復(fù)制右半部分,對應(yīng)下圖中綠色部分
        System.arraycopy(elements, 0, a, r, p);//復(fù)制左半部分,對應(yīng)下圖中灰色部分
        elements = a;
        head = 0;
        tail = n;
    }

其邏輯是申請一個更大的數(shù)組(原數(shù)組的兩倍),然后將原數(shù)組復(fù)制過去。

Java Review - Queue和Stack 源碼解讀_拋出異常_14
圖中我們看到,復(fù)制分兩次進(jìn)行,第一次復(fù)制head右邊的元素,第二次復(fù)制head左邊的元素。


addLast()

則調(diào)用doubleCapacity()進(jìn)行擴(kuò)容。

    /**
     * Inserts the specified element at the end of this deque.
     *
     * <p>This method is equivalent to {@link #add}.
     *
     * @param e the element to add
     * @throws NullPointerException if the specified element is null
     */
    public void addLast(E e) {
        if (e == null) //不允許放入null
            throw new NullPointerException();
        elements[tail] = e; //賦值
        if ( (tail = (tail + 1) & (elements.length - 1)) == head) //下標(biāo)越界處理
            doubleCapacity();//擴(kuò)容
    }

addLast(E e)的作用是在Deque的尾端插入元素,也就是在tail的位置插入元素,由于tail總是指向下一個可以插入的空位,因此只需要elements[tail] = e;即可。插入完成后再檢查空間,如果空間已經(jīng)用光調(diào)用doubleCapacity()進(jìn)行擴(kuò)容。

Java Review - Queue和Stack 源碼解讀_拋出異常_15


pollFirst()

public E pollFirst() {
    E result = elements[head];
    if (result == null)//null值意味著deque為空
        return null;
    elements[h] = null;//let GC work
    head = (head + 1) & (elements.length - 1);//下標(biāo)越界處理
    return result;
}

pollFirst()的作用是刪除并返回Deque首端元素,也即是head位置處的元素。

如果容器不空,只需要直接返回elements[head]即可,當(dāng)然還需要處理下標(biāo)的問題。由于ArrayDeque中不允許放入null,當(dāng)elements[head] == null時,意味著容器為空。

Java Review - Queue和Stack 源碼解讀_拋出異常_16


pollLast()

 public E pollLast() {
    int t = (tail - 1) & (elements.length - 1);//tail的上一個位置是最后一個元素
    E result = elements[t];
    if (result == null)//null值意味著deque為空
        return null;
    elements[t] = null;//let GC work
    tail = t;
    return result;
}


pollLast()的作用是刪除并返回Deque尾端元素,也即是tail位置前面的那個元素。

Java Review - Queue和Stack 源碼解讀_Queue_17


peekFirst()

public E peekFirst() {
    return elements[head]; // elements[head] is null if deque empty
}

peekFirst()的作用是返回但不刪除Deque首端元素,也即是head位置處的元素,直接返回elements[head]即可
Java Review - Queue和Stack 源碼解讀_數(shù)組_18


peekLast()

public E peekLast() {
    return elements[(tail - 1) & (elements.length - 1)];
}

peekLast()的作用是返回但不刪除Deque尾端元素,也即是tail位置前面的那個元素。

Java Review - Queue和Stack 源碼解讀_數(shù)組_19

本文摘自 :https://blog.51cto.com/u

開通會員,享受整站包年服務(wù)立即開通 >