srcmini存在于java.util打包并扩展采集界面用于按FIFO(先进先出)顺序保存要处理的元素。它是对象的有序列表, 其使用仅限于在列表末尾插入元素, 并从列表的开头删除元素(即, 它遵循FIFO或先进先出原则)。
作为接口, 队列需要一个具体的类进行声明, 最常见的类是PriorityQueue和链表请注意, 这两种实现都不是线程安全的。PriorityBlockingQueue如果需要线程安全的实现, 则是一种替代实现。
宣言：队列接口声明为：
public interface Queue extends Collection
创建队列对象
以来队列是一个接口, 无法创建队列类型的对象。我们总是需要一个扩展此列表的类以创建一个对象。而且, 在引入泛型在Java 1.5中, 可以限制可以存储在队列中的对象的类型。此类型安全队列可以定义为：
// Obj是要存储在队列中的对象的类型Queue <Obj> queue = new PriorityQueue <Obj>();
队列示例：
// 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.添加元素：为了在队列中添加元素, 我们可以使用add()方法。插入顺序不会保留在PriorityQueue中。元素是根据默认的升序排列的。
// 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.删除元素：为了从队列中删除元素, 我们可以使用remove()方法。如果存在多个此类对象, 则将删除对象的第一个匹配项。除此之外, poll()方法还用于移除头部并返回它。
// 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 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 Queue支持Collection接口的所有方法, 包括插入, 删除等。
- 链表, ArrayBlockingQueue和PriorityQueue是最常用的实现。
- 如果对BlockingQueues执行了任何null操作, 则抛出NullPointerException。
- java.util软件包中可用的队列是”无界队列”。
- 在java.util.concurrent包中可用的队列是Bounded Queues。
- 除双端队列外, 所有队列分别支持在队列的尾部和头部插入和删除。 Deques支撑元件在两端都可以插入和移除。
实现队列接口的类：
1. PriorityQueue：在收集框架中实现的PriorityQueue类为我们提供了一种基于优先级处理对象的方法。众所周知, 队列遵循先进先出算法, 但是有时需要根据优先级来处理队列的元素, 即PriorityQueue起作用。让我们看看如何使用此类创建队列对象。
// 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
152.链表：LinkedList是在收集框架中实现的类, 该框架固有地实现了链表数据结构。它是一种线性数据结构, 其中元素没有存储在连续的位置, 并且每个元素都是具有数据部分和地址部分的单独对象。元素使用指针和地址链接。每个元素称为一个节点。由于动态性以及插入和删除的简便性, 它们比数组或队列更可取。让我们看看如何使用此类创建队列对象。
// 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
203.PriorityBlockingQueue：要注意的是, PriorityQueue和LinkedList这两种实现都不是线程安全的。如果需要线程安全的实现, PriorityBlockingQueue是一种替代实现。 PriorityBlockingQueue是一个无界阻塞队列, 它使用与类相同的排序规则PriorityQueue并提供阻止检索操作。
由于它是不受限制的, 因此添加元素有时可能会由于资源耗尽而失败, 从而导致OutOfMemoryError。让我们看看如何使用此类创建队列对象。
// 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队列接口方法
队列接口继承了集合界面同时实现以下方法：
| 方法 | 描述 |
|---|---|
| add(element) | 此方法用于在队列尾部添加元素。更具体地说, 如果使用链表, 则在链表的最后, 或者在实施优先队列的情况下, 根据优先级。 |
| element() | 此方法类似于peek()。队列为空时, 它将引发NoSuchElementException。 |
| offer(element) | 此方法用于在队列中插入元素。此方法比add()方法更可取, 因为在容器的容量已满时, 此方法不会引发异常, 因为它会返回false。 |
| peek() | 此方法用于查看队列头而不删除它。如果队列为空, 则返回Null。 |
| poll() | 此方法删除并返回队列的头部。如果队列为空, 则返回null。 |
| remove() | 此方法删除并返回队列的头部。队列为空时, 它将引发NoSuchElementException。 |
评论前必须登录！
注册