Java AbstractQueue用法及代码示例

AbstractQueueJava 中的类是Java集合框架并实施集合接口和AbstractCollection类。它提供了一些框架的实现队列运营。当基本实现不允许空元素时，此类中的实现是合适的。 add、remove 和 element 方法分别基于 Offer、poll 和 peek，但会抛出异常，而不是通过 false 或 null 返返回指示失败。
类层次结构：

java.lang.Object
 ↳ java.util.AbstractCollection<E>
    ↳ Class AbstractQueue<E>

AbstractQueue in Java

这个类实现了可迭代<E>,集合<E>,Queue接口和扩展AbstractCollection

声明：

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

E - 由集合框架类或接口维护的元素类型。

Java 中的构造函数AbstractQueue

由于AbstractQueue是一个抽象类，因此它的实现由其子类提供。下面显示了可以提供实现的类的列表。要创建它，我们需要从 java.util.AbstractQueue 中获取它。

受保护AbstractQueue()：默认构造函数，但由于是抽象的，因此不允许创建AbstractQueue对象。该实现应该由其子类之一提供，例如ArrayBlockingQueue,ConcurrentLinkedQueue,DelayQueue Class,LinkedBlockingDeque,LinkedBlockingQueue,LinkedTransferQueue,PriorityBlockingQueue,PriorityQueue,SynchronousQueue.

AbstractQueue<E> objName = new ArrayBlockingQueue<E>();

下面是一个示例程序，用于说明 Java 中的AbstractQueue：

Java


// Java code to illustrate AbstractQueue
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
public class AbstractQueueExample {
    public static void main(String[] argv) throws Exception
    {
        // Creating object of AbstractQueue<Integer>
        AbstractQueue<Integer> AQ = new LinkedBlockingQueue<Integer>();
        // Adding elements to the Queue
        AQ.add(10);
        AQ.add(20);
        AQ.add(30);
        AQ.add(40);
        AQ.add(50);
        // print the queue contents to the console
        System.out.println("AbstractQueue contains: " + AQ);
    }
}

输出：

AbstractQueue contains: [10, 20, 30, 40, 50]

Basic Operations

1. 添加元素

为了向 AbstractQueue 添加元素，它提供了两种方法。这AbstractQueue add()方法将指定的元素插入到此队列中(如果可以立即执行此操作而不违反容量限制)。成功后返回 true 并抛出IllegalStateException如果当前没有可用空间。这AbstractQueue addAll()方法将指定集合中的所有元素添加到此队列中。

Java


// Java program to illustrate the
// adding elements to the AbstractQueue
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
public class AddingElementsExample {
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
        // Populating AQ
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
        // print AQ
        System.out.println("AbstractQueue contains : "
                           + AQ1);
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ2 = new LinkedBlockingQueue<Integer>();
        // print AQ2 initially
        System.out.println("AbstractQueue2 initially contains : " + AQ2);
        // adds elements of AQ1 in AQ2
        AQ2.addAll(AQ1);
        System.out.println( "AbstractQueue1 after addition contains : " + AQ2);
    }
}

输出

AbstractQueue contains : [10, 20, 30, 40, 50]
AbstractQueue2 initially contains : []
AbstractQueue1 after addition contains : [10, 20, 30, 40, 50]

2. 删除元素

要从 AbstractQueue 中删除元素，它提供了 remove() 和 clear() 方法。

remove() 方法返回并删除该队列的头部。
clear() 方法从该队列中删除所有元素。该调用返回后队列将为空。

Java


// Java program to illustrate the
// removal of elements from AbstractQueue
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
public class RemovingElementsExample {
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
        // Add elements using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
        // print the queue contents to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);
        // Retrieves the head
        int head = AQ1.remove();
        // print the head element to the console
        System.out.println("head : " + head);
        // print the modified queue
        System.out.println("AbstractQueue1 after removal of head : " + AQ1);
        // remove all the elements
        AQ1.clear();
        // print the modified queue
        System.out.println("AbstractQueue1 : " + AQ1);
    }
}

输出

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10
AbstractQueue1 after removal of head : [20, 30, 40, 50]
AbstractQueue1 : []

3. 访问元素

AbstractQueue 的 element() 方法检索但不删除该队列的头部。

Java


// Java program to illustrate the
// accessing element from AbstractQueue
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
public class AccessingElementExample {
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
        // Populating AQ1 using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
        // print AQ to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);
        // access the head element
        System.out.println("head : " + AQ1.element());
    }
}

输出

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10

AbstractQueue的方法

METHOD	DESCRIPTION
add(E e)	如果可以在不违反容量限制的情况下立即将指定元素插入此队列，则成功时返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
addAll(集合 <? 扩展 E> c)	将指定集合中的所有元素添加到此队列中。
clear()	从此队列中删除所有元素。
element()	检索但不删除此队列的头部。
remove()	检索并删除此队列的头部。

类 java.util.AbstractCollection 中声明的方法

METHOD	DESCRIPTION
contains(Object o)	如果此集合包含指定元素，则返回 true。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
isEmpty()	如果此集合不包含任何元素，则返回 true。
iterator()	返回此集合中包含的元素的迭代器。
remove(Object o)	从此集合中删除指定元素的单个实例(如果存在)(可选操作)。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
toArray()	返回一个包含此集合中所有元素的数组。
toArray(T[] a)	返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
toString()	返回此集合的字符串表示形式。

接口 java.util.Collection 中声明的方法

METHOD	DESCRIPTION
contains(Object o)	如果此集合包含指定元素，则返回 true。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
equals(Object o)	比较指定对象与此集合是否相等。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含任何元素，则返回 true。
iterator()	返回此集合中元素的迭代器。
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
remove(Object o)	从此集合中删除指定元素的单个实例(如果存在)(可选操作)。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
size()	返回此集合中的元素数量。
spliterator()	在此集合中的元素上创建一个 Spliterator。
stream()	返回以此集合作为源的顺序 Stream。
toArray()	返回一个包含此集合中所有元素的数组。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。
toArray(T[] a)	返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

接口 java.lang.Iterable 中声明的方法

METHOD	DESCRIPTION
Iterable forEach()	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。

接口 java.util.Queue 中声明的方法

METHOD	DESCRIPTION
Queue offer()	如果可以在不违反容量限制的情况下立即执行此操作，则将指定元素插入此队列。
Queue peek()	检索但不删除此队列的头部，如果此队列为空，则返回 null。
Queue poll()	检索并删除此队列的头部，如果此队列为空，则返回 null。

参考： https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/AbstractQueue.html

解释

在Java中，抽象队列是一种遵循先进先出(First-In-First-Out)原则的数据结构，这意味着添加到队列中的第一个元素是第一个被删除的元素。抽象队列是一个抽象类，它作为Java中各种队列实现的基类。

抽象队列提供了一组所有队列实现都通用的方法，例如向队列后面添加元素、从队列前面删除元素以及在不进行任何操作的情况下查看队列前面的元素。删除它。这些方法在抽象类中定义，可以被具体队列实现覆盖。

抽象队列类提供的一些常用方法是：

add()：该方法用于向队列末尾添加一个元素。如果队列已满，则会抛出异常。

offer()：该方法用于向队列末尾添加一个元素。如果队列已满，则返回 false。

remove()：该方法用于移除并返回队列前面的元素。如果队列为空，则会抛出异常。

poll()：该方法用于移除并返回队列前面的元素。如果队列为空，则返回null。

element()：该方法用于查看队列前面的元素而不删除它。如果队列为空，则会抛出异常。

peek()：该方法用于查看队列前面的元素而不删除它。如果队列为空，则返回null。

Java中抽象队列的一些具体实现是：

LinkedList：Java中的LinkedList类实现了Queue接口，并提供了抽象队列的具体实现。

ArrayDeque：Java中的ArrayDeque类提供了抽象队列的resizable-array实现。

PriorityQueue：Java中的PriorityQueue类提供了一个基于优先级堆的无界优先级队列。

Java 中的抽象队列在各种需要按照添加顺序处理元素的应用程序中非常有用。它用于以下情况：

在消息系统中实现消息队列。

在多线程应用程序中实现任务队列。

在流系统中实现数据处理的缓冲区。

总的来说，Java 中的抽象队列是一个通用且强大的工具，用于以先进先出的方式管理数据集合。

程序

Java


import java.util.Queue;
import java.util.LinkedList;
public class QueueExample {
    public static void main(String[] args) {
        // Create a new queue
        Queue<String> queue = new LinkedList<>();
        // Add elements to the queue
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");
        queue.add("David");
        // Print the elements in the queue
        System.out.println("Queue: " + queue);
        // Remove the first element from the queue
        String first = queue.remove();
        System.out.println("Removed element: " + first);
        // Print the remaining elements in the queue
        System.out.println("Queue: " + queue);
        // Peek at the first element in the queue
        String peeked = queue.peek();
        System.out.println("Peeked element: " + peeked);
        // Print the remaining elements in the queue
        System.out.println("Queue: " + queue);
    }
}

输出

Queue: [Alice, Bob, Charlie, David]
Removed element: Alice
Queue: [Bob, Charlie, David]
Peeked element: Bob
Queue: [Bob, Charlie, David]

在此示例中，我们使用具体实现 LinkedList 创建一个新队列。然后，我们将四个元素添加到队列中，并使用 System.out.println() 语句打印这些元素。

然后，我们使用 remove() 方法从队列中删除第一个元素并打印删除的元素。我们使用 System.out.println() 语句再次打印队列中的剩余元素。

然后，我们使用 peek() 方法查看队列中的第一个元素并打印查看的元素。最后，我们使用 System.out.println() 语句打印队列中的剩余元素。

时间和空间复杂度

Java 中抽象队列的时间和空间复杂度取决于所使用的具体实现。在这个例子中，我们使用LinkedList来实现队列。

对LinkedList的各种操作的时间复杂度如下：

添加(元素)：O(1)
remove()：O(1)
peek()：O(1)
因此，向队列添加一个元素、从队列中删除一个元素以及查看队列中的第一个元素的时间复杂度都是 O(1)。

使用 LinkedList 实现的队列的空间复杂度为 O(n)，其中 n 是队列中元素的数量。这是因为 LinkedList 内部使用动态数组来存储其元素，当添加或删除元素时可能需要调整该数组的大小。但是，确切的空间复杂度可能取决于LinkedList 类的实现细节。

综上所述，使用 LinkedList 实现的抽象队列中添加、删除和查看元素的时间复杂度为 O(1)，空间复杂度为 O(n)

相关用法

注：本文由纯净天空筛选整理自RishabhPrabhu大神的英文原创作品 AbstractQueue in Java with Examples。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。