queue interface

Java Queue Interface, Implementations and Example

A Queue is a collection used to hold multiple elements prior to processing. Besides basic Collection operations, queue interface provides additional insertion, removal, and examine operations as mentioned below.

Queue Interface Java SE 8

Queues typically, but not necessarily, order elements in a FIFO (first-in-first-out) manner.

Each Queue interface method exists in two forms

  1. Methods that throws exception, if the operation fails – add(e), remove(), element().
  2. Methods that returns a special value, if the operation fails (either null or false) – offer(e), poll(), peek().

Difference between element() and peek()

You might expect this interview question on the the difference between element() and peek() methods of Queue interface ?

The answer is: the commonality is both retrieves head element of the queue, but the element() differs from peek() only in that it throws an exception if queue is empty and peek() returns null in this case.

offer(e) Vs add(e)

The method offer(e) inserts the specified element in to the queue if it is possible to do without violating capacity restrictions. When you use capacity-restricted queue in your implementation offer(e) method is preferred over add(e) method, which can fail to insert an element and just throws an exception.

Example: Queue Interface

Output

Implementations of “Queue” Interface

The following are the general-purpose implementations of Queue interface

  • LinkedList: It implements the Queue interface, providing FIFO queue operations for add, poll, and so on.
  • PriorityQueue: It is a priority queue based on the heap data structure. This queue orders elements according to an order specified at construction time, which can be the natural ordering of the elements or the ordering imposed by an explicit Comparator.

The following are the Concurrent Queue implementations classes

The java.util.concurrent package contains a set of synchronized Queue interfaces and classes. BlockingQueue extends Queue with operations that wait for the queue to become nonempty when retrieving an element and for space to become available in the queue when storing an element. This interface is implemented by the following classes:

  • ArrayBlockingQueue: A bounded FIFO blocking queue backed by an array.
  • DelayQueue: A scheduling queue based on time backed by a heap
  • LinkedBlockingQueue: An optionally-bounded FIFO blocking queue backed by linked nodes.
  • LinkedBlockingDeque: An optionally-bounded blocking deque based on linked nodes.
  • LinkedTransferQueue: An unbounded TransferQueue based on linked nodes.
  • PriorityBlockingQueue: An unbounded blocking priority queue backed by a heap.
  • SynchronousQueue: A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.

Related Posts

Reference

Leave a Reply

avatar
  Subscribe  
Notify of