Java Queue用法及代碼示例

隊列接口存在於java.util封裝並擴展采集接口用於以 FIFO(先進先出)順序保存要處理的元素。它是一個有序的對象列表，其用途僅限於在列表末尾插入元素和從列表開頭刪除元素，(即)，它遵循FIFO或First-In-First-Out 原則。

Queue-Deque-PriorityQueue-In-Java

作為一個接口，隊列需要一個具體的類來聲明，最常見的類是PriorityQueue和LinkedList在 Java 。請注意，這些實現都不是線程安全的。PriorityBlockingQueue如果需要線程安全實現，這是一種替代實現。

聲明：Queue 接口聲明為：

public interface Queue extends Collection

創建隊列對象：自從隊列是一個接口，不能創建隊列類型的對象。我們總是需要一個擴展這個列表的類來創建一個對象。而且，推出後泛型在Java 1.5中，可以限製可以存儲在Queue中的對象的類型。這個類型安全隊列可以定義為：

// Obj is the type of the object to be stored in Queue 
Queue<Obj> queue = new PriorityQueue<Obj> ();

在 Java 中，Queue 接口是 Collection 接口的子類型，表示按特定順序排列的元素的集合。它遵循 first-in、first-out (FIFO) 原則，這意味著元素按照添加到隊列的順序檢索。

Queue 接口提供了多種用於添加、刪除和檢查隊列中元素的方法。以下是一些最常用的方法：

add(element)：將一個元素添加到隊列的末尾。如果隊列已滿，則會拋出異常。

Offer(element)：將一個元素添加到隊列的末尾。如果隊列已滿，則返回 false。

remove()：刪除並返回隊列前麵的元素。如果隊列為空，則會拋出異常。

poll()：刪除並返回隊列前麵的元素。如果隊列為空，則返回null。

element()：返回隊列前麵的元素而不刪除它。如果隊列為空，則會拋出異常。

peek()：返回隊列前麵的元素而不刪除它。如果隊列為空，則返回null。

Queue 接口由 Java 中的幾個類實現，包括 LinkedList、ArrayDeque 和 PriorityQueue。每個類都提供隊列接口的不同實現，具有不同的性能特征和函數。

總體而言，Queue 接口是按特定順序管理元素集合的有用工具，並且廣泛用於許多不同的應用程序和行業。

例子：

Java


import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        // add elements to the queue
        queue.add("apple");
        queue.add("banana");
        queue.add("cherry");
        // print the queue
        System.out.println("Queue: " + queue);
        // remove the element at the front of the queue
        String front = queue.remove();
        System.out.println("Removed element: " + front);
        // print the updated queue
        System.out.println("Queue after removal: " + queue);
        // add another element to the queue
        queue.add("date");
        // peek at the element at the front of the queue
        String peeked = queue.peek();
        System.out.println("Peeked element: " + peeked);
        // print the updated queue
        System.out.println("Queue after peek: " + queue);
    }
}

輸出

Queue: [apple, banana, cherry]
Removed element: apple
Queue after removal: [banana, cherry]
Peeked element: banana
Queue after peek: [banana, cherry, date]

例子：隊列

Java


// Java program to demonstrate a Queue
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
    public static void main(String[] args)
    {
        Queue<Integer> q
            = new LinkedList<>();
        // Adds elements {0, 1, 2, 3, 4} to
        // the queue
        for (int i = 0; i < 5; i++)
            q.add(i);
        // Display contents of the queue.
        System.out.println("Elements of queue "
                           + q);
        // To remove the head of queue.
        int removedele = q.remove();
        System.out.println("removed element-"
                           + removedele);
        System.out.println(q);
        // To view the head of queue
        int head = q.peek();
        System.out.println("head of queue-"
                           + head);
        // Rest all methods of collection
        // interface like size and contains
        // can be used with this
        // implementation.
        int size = q.size();
        System.out.println("Size of queue-"
                           + size);
    }
}

輸出

Elements of queue [0, 1, 2, 3, 4]
removed element-0
[1, 2, 3, 4]
head of queue-1
Size of queue-4

隊列接口操作

讓我們看看如何使用以下命令對隊列執行一些常用操作優先隊列類.

1. 添加元素：為了向隊列中添加元素，我們可以使用Queue add()。 PriorityQueue 中不保留插入順序。元素按照優先級順序存儲，默認為升序。

示例

Java


// Java program to add elements
// to a Queue
import java.util.*;
public class GFG {
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
        System.out.println(pq);
    }
}

輸出

[For, Geeks, Geeks]

2. 刪除元素：為了從隊列中刪除一個元素，我們可以使用Queue remove()如果存在多個此類對象，則刪除第一個出現的對象。除此之外，poll()方法也用於移除頭部並將其返回。

示例

Java


// Java program to remove elements
// from a Queue
import java.util.*;
public class GFG {
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
        System.out.println("Initial Queue " + pq);
        pq.remove("Geeks");
        System.out.println("After Remove " + pq);
        System.out.println("Poll Method " + pq.poll());
        System.out.println("Final Queue " + pq);
    }
}

輸出

Initial Queue [For, Geeks, Geeks]
After Remove [For, Geeks]
Poll Method For
Final Queue [Geeks]

3. 迭代隊列：有多種方法可以迭代隊列。最著名的方法是將隊列轉換為數組並使用for循環進行遍曆。但是，隊列還有一個內置迭代器，可用於迭代隊列。

示例

Java


// Java program to iterate elements
// to a Queue
import java.util.*;
public class GFG {
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
        Iterator iterator = pq.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

輸出

For Geeks Geeks

隊列的特點：隊列的特點如下：

隊列用於在隊列末尾插入元素並從隊列開頭刪除元素。它遵循 FIFO 概念。
Java隊列支持Collection接口的所有方法，包括插入、刪除等。
LinkedList、ArrayBlockingQueue 和PriorityQueue是最常用的實現。
如果對BlockingQueues執行任何空操作，則會拋出NullPointerException。
java.util 包中可用的隊列是無界隊列。
java.util.concurrent 包中提供的隊列是有界隊列。
除雙端隊列外，所有隊列都支持分別在隊列尾部和頭部插入和刪除。 Deques支持兩端元素的插入和移除。

實現隊列接口的類：

1. 優先隊列：集合框架中實現的PriorityQueue類為我們提供了一種基於優先級處理對象的方法。眾所周知，隊列遵循First-In-First-Out算法，但有時需要根據優先級處理隊列中的元素，這時PriorityQueue就發揮作用了。讓我們看看如何使用此類創建隊列對象。

示例

Java


// Java program to demonstrate the
// creation of queue object using the
// PriorityQueue class
import java.util.*;
class GfG {
    public static void main(String args[])
    {
        // Creating empty priority queue
        Queue<Integer> pQueue
            = new PriorityQueue<Integer>();
        // Adding items to the pQueue
        // using add()
        pQueue.add(10);
        pQueue.add(20);
        pQueue.add(15);
        // Printing the top element of
        // the PriorityQueue
        System.out.println(pQueue.peek());
        // Printing the top element and removing it
        // from the PriorityQueue container
        System.out.println(pQueue.poll());
        // Printing the top element again
        System.out.println(pQueue.peek());
    }
}

輸出

10
10
15

2. 鏈表：LinkedList 是一個在集合框架中實現的類，它本質上實現了鏈表數據結構。它是一種線性數據結構，其中元素不存儲在連續位置，並且每個元素都是具有數據部分和地址部分的單獨對象。這些元素使用指針和地址鏈接。每個元素稱為一個節點。由於插入和刪除的動態性和簡便性，它們比數組或隊列更受青睞。讓我們看看如何使用此類創建隊列對象。

示例

Java


// Java program to demonstrate the
// creation of queue object using the
// LinkedList class
import java.util.*;
class GfG {
    public static void main(String args[])
    {
        // Creating empty LinkedList
        Queue<Integer> ll
            = new LinkedList<Integer>();
        // Adding items to the ll
        // using add()
        ll.add(10);
        ll.add(20);
        ll.add(15);
        // Printing the top element of
        // the LinkedList
        System.out.println(ll.peek());
        // Printing the top element and removing it
        // from the LinkedList container
        System.out.println(ll.poll());
        // Printing the top element again
        System.out.println(ll.peek());
    }
}

輸出

10
10
20

3. PriorityBlockingQueue需要注意的是，PriorityQueue 和 LinkedList 這兩種實現都不是線程安全的。如果需要線程安全實現，PriorityBlockingQueue 是一種替代實現。 PriorityBlockingQueue是一個無界阻塞隊列，使用與class相同的排序規則PriorityQueue並提供阻塞檢索操作。
由於是無界的，添加元素有時可能會因為資源耗盡而失敗，導致OutOfMemoryError。讓我們看看如何使用此類創建隊列對象。

示例

Java


// Java program to demonstrate the
// creation of queue object using the
// PriorityBlockingQueue class
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
class GfG {
    public static void main(String args[])
    {
        // Creating empty priority
        // blocking queue
        Queue<Integer> pbq
            = new PriorityBlockingQueue<Integer>();
        // Adding items to the pbq
        // using add()
        pbq.add(10);
        pbq.add(20);
        pbq.add(15);
        // Printing the top element of
        // the PriorityBlockingQueue
        System.out.println(pbq.peek());
        // Printing the top element and
        // removing it from the
        // PriorityBlockingQueue
        System.out.println(pbq.poll());
        // Printing the top element again
        System.out.println(pbq.peek());
    }
}

輸出

10
10
15

隊列接口方法

隊列接口繼承了隊列中存在的所有方法集合接口同時實施以下方法：

方法	說明
List add(int index, E element)	此方法用於在隊列中的特定索引處添加元素。當傳遞單個參數時，它隻是將元素添加到隊列末尾。
List addAll()	該方法用於將給定集合中的所有元素添加到隊列中。當傳遞單個參數時，它會將給定集合的所有元素添加到隊列末尾。
List size()	該方法用於返回隊列的大小。
List clear()	該方法用於刪除隊列中的所有元素。但是，創建的隊列的引用仍然被存儲。
Queue remove()	該方法用於從隊列的前麵刪除元素。
List remove(int index)	此方法從指定索引中刪除一個元素。它將後續元素(如果有)向左移動，並將其索引減 1。
remove(element)	此方法用於刪除並返回隊列中第一次出現的給定元素。
List get()	此方法返回指定索引處的元素。
ArrayList set()	此方法用新元素替換給定索引處的元素。該函數返回剛剛被新元素替換的元素。
List indexOf()	此方法返回給定元素的第一次出現或-1如果該元素不存在於隊列中。
List lastIndexOf()	此方法返回給定元素的最後一次出現或-1如果該元素不存在於隊列中。
equals(element)	該方法用於比較給定元素與隊列元素的相等性。
hashCode()	該方法用於返回給定隊列的哈希碼值。
isEmpty()	該方法用於檢查隊列是否為空。如果隊列為空則返回 true，否則返回 false。
contains(element)	該方法用於檢查隊列是否包含給定元素。如果隊列包含該元素，則返回 true。
List containsAll()	該方法用於檢查隊列是否包含所有元素的集合。
sort(Comparator comp)	該方法用於根據給定的條件對隊列中的元素進行排序Comparator Interface.
布爾加法(對象)	該方法用於將指定元素插入隊列，成功則返回true。
布爾引號(對象)	該方法用於將指定元素插入到隊列中。
對象poll()	該方法用於檢索並刪除隊列的頭部，如果隊列為空則返回 null。
對象element()	此方法用於檢索但不刪除隊列頭。
對象peek()	此方法用於檢索但不刪除此隊列的頭，或者如果此隊列為空則返回 null。

在Java中使用Queue接口的優點：

訂單保存：Queue 接口提供了一種按照特定順序存儲和檢索元素的方法，遵循 first-in、first-out (FIFO) 原則。

靈活性：Queue 接口是 Collection 接口的子類型，這意味著它可以與許多不同的數據結構和算法一起使用，具體取決於應用程序的要求。

線-安全：Queue 接口的一些實現，例如 java.util.concurrent.ConcurrentLinkedQueue 類，是線程安全的，這意味著它們可以被多個線程同時訪問而不會引起衝突。

性能：Queue 接口提供了添加、刪除和檢查元素的高效實現，使其成為管理 performance-critical 應用程序中元素集合的有用工具。

在Java中使用Queue接口的缺點：

函數有限：Queue 接口是專門為管理特定順序的元素集合而設計的，這意味著它可能不適合更複雜的數據結構或算法。

尺寸限製：Queue 接口的某些實現(例如 ArrayDeque 類)具有固定大小，這意味著它們的增長不能超過一定數量的元素。

內存使用情況：根據實現的不同，Queue 接口可能比其他數據結構需要更多的內存，特別是當它需要存儲有關元素順序的附加信息時。

複雜度：對於新手程序員來說，Queue 接口可能很難使用和理解，尤其是在他們不熟悉數據結構和算法原理的情況下。

相關用法

注：本文由純淨天空篩選整理自佚名大神的英文原創作品 Queue Interface In Java。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。