个性化阅读
专注于IT技术分析

Java中的队列接口Queue的用法详细指南

存在于java.util打包并扩展采集界面用于按FIFO(先进先出)顺序保存要处理的元素。它是对象的有序列表, 其使用仅限于在列表末尾插入元素, 并从列表的开头删除元素(即, 它遵循FIFO或先进先出原则)。

Java 队列 双端队列 优先队列

作为接口, 队列需要一个具体的类进行声明, 最常见的类是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
15

2.链表: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
20

3.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。
赞(0) 打赏
未经允许不得转载:srcmini » Java中的队列接口Queue的用法详细指南
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!

 

觉得文章有用就打赏一下文章作者

微信扫一扫打赏