Java Queue 接口

队列接口存在于java.util包中，并扩展了Collection接口，用于保存即将以FIFO（先进先出）顺序处理的元素。它是一个有序的对象列表，其用途仅限于在列表的末尾插入元素和从列表的开头删除元素，（即）它遵循 先进先出 的原则。

Java中的队列接口

作为一个接口，队列需要一个具体的类来声明，最常见的类是Java中的PriorityQueue和LinkedList。请注意，这些实现都不是线程安全的。如果需要线程安全的实现，PriorityBlockingQueue是一种替代性的实现。

声明： 队列接口被声明为。

public interface Queue extends Collection

创建队列对象： 由于队列是一个接口，不能创建队列类型的对象。我们总是需要一个扩展这个列表的类来创建一个对象。而且，在Java 1.5引入泛型之后，我们可以限制可以存储在队列中的对象的类型。这个类型安全的队列可以定义为：。

// Obj is the type of the object to be stored in Queue 
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队列支持集合接口的所有方法，包括插入、删除等。
LinkedList、ArrayBlockingQueue和PriorityQueue是最常使用的实现方式。
如果对阻塞队列进行任何空操作，就会抛出NullPointerException。
java.util包中的队列是无界队列。
java.util.concurrent包中的队列是有界队列。
除了Deques之外，所有的队列都分别支持在队列的尾部和头部进行插入和删除。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： 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(int index, element)	这个方法用来在队列中的某个特定索引处添加一个元素。当一个参数被传递时，它只是在队列的末端添加元素。
addAll(int index, Collection collection)	这个方法用来添加给定集合中的所有元素到队列中。当传递一个参数时，它在队列的末尾添加给定集合的所有元素。
size()	该方法用于返回队列的大小。
clear()	这个方法用来删除队列中的所有元素。然而，创建的队列的引用仍然被保存。
remove()	这个方法用来从队列的前面删除元素。
remove(int index)	这个方法从指定的索引中删除一个元素。它将随后的元素（如果有的话）向左移动并将它们的索引减少1。
remove(element)	该方法用于删除并返回队列中第一次出现的给定元素。
get(int index)	该方法返回指定索引的元素。
set(int index, element)	这个方法用新的元素替换给定索引上的元素。这个函数返回刚刚被新元素替换的元素。
indexOf(element)	该方法返回给定元素的第一次出现，如果该元素在队列中不存在，则返回 -1 。
lastIndexOf(element)	该方法返回给定元素的最后一次出现，如果该元素在队列中不存在，则返回 -1 。
equals(element)	该方法用于比较给定元素与队列中的元素是否相等。
hashCode()	该方法用于返回给定队列的哈希代码值。
isEmpty()	该方法用于检查队列是否为空。如果队列是空的，它返回 true，否则返回 false。
contains(element)	该方法用于检查队列是否包含给定的元素。如果队列包含该元素，它返回真。
containsAll(Collection)	该方法用于检查队列是否包含所有的元素集合。
sort(Comparator comp)	该方法用于在给定的比较器的基础上对队列中的元素进行排序。
boolean add(object)	该方法用于将指定的元素插入队列中，成功后返回true。
boolean offer(object)	该方法用于将指定的元素插入队列中。
Object poll()	该方法用于检索和删除队列的头部，如果队列是空的，则返回null。
Object element()	这个方法用于检索，但不删除队列的头部。
Object peek()	这个方法用来检索，但不删除这个队列的头部，如果这个队列是空的，则返回null。