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。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。