Package com.google.common.collect

Class MinMaxPriorityQueue<E>

  • All Implemented Interfaces:
    Iterable<E>, Collection<E>, Queue<E>
    @Beta
@GwtCompatible
public final class MinMaxPriorityQueue<E>
extends AbstractQueue<E>
    A double-ended priority queue, which provides constant-time access to both its least element and its greatest element, as determined by the queue's specified comparator. If no comparator is given at creation time, the natural order of elements is used. If no maximum size is given at creation time, the queue is unbounded.

    Usage example: 

    
 MinMaxPriorityQueue<User> users = MinMaxPriorityQueue.orderedBy(userComparator)
     .maximumSize(1000)
     .create();

    As a Queue it functions exactly as a PriorityQueue: its head element -- the implicit target of the methods peek(), poll() and AbstractQueue.remove() -- is defined as the least element in the queue according to the queue's comparator. But unlike a regular priority queue, the methods peekLast(), pollLast() and removeLast() are also provided, to act on the greatest element in the queue instead.

    A min-max priority queue can be configured with a maximum size. If so, each time the size of the queue exceeds that value, the queue automatically removes its greatest element according to its comparator (which might be the element that was just added). This is different from conventional bounded queues, which either block or reject new elements when full.

    This implementation is based on the min-max heap developed by Atkinson, et al. Unlike many other double-ended priority queues, it stores elements in a single array, as compact as the traditional heap data structure used in PriorityQueue.

    This class is not thread-safe, and does not accept null elements.

    Performance notes:

    Since:
    8.0
    Author:
    Sverre Sundsdal, Torbjorn Gannholm

    • Method Detail

      • create

        public static <E extends Comparable<E>> MinMaxPriorityQueue<E> create()
        Creates a new min-max priority queue with default settings: natural order, no maximum size, no initial contents, and an initial expected size of 11.

      • create

        public static <E extends Comparable<E>> MinMaxPriorityQueue<E> create​(Iterable<? extends E> initialContents)
        Creates a new min-max priority queue using natural order, no maximum size, and initially containing the given elements.

      • orderedBy

        public static <B> MinMaxPriorityQueue.Builder<B> orderedBy​(Comparator<B> comparator)
        Creates and returns a new builder, configured to build MinMaxPriorityQueue instances that use comparator to determine the least and greatest elements.

      • maximumSize

        public static MinMaxPriorityQueue.Builder<Comparable> maximumSize​(int maximumSize)
        Creates and returns a new builder, configured to build MinMaxPriorityQueue instances that are limited to maximumSize elements. Each time a queue grows beyond this bound, it immediately removes its greatest element (according to its comparator), which might be the element that was just added.

      • size

        public int size()
        Description copied from interface: java.util.Collection
        Returns the number of elements in this collection. If this collection contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
        Specified by:
        size in interface Collection<E>
        Specified by:
        size in class AbstractCollection<E>
        Returns:
        the number of elements in this collection

      • add

        @CanIgnoreReturnValue
public boolean add​(E element)
        Adds the given element to this queue. If this queue has a maximum size, after adding element the queue will automatically evict its greatest element (according to its comparator), which may be element itself.
        Specified by:
        add in interface Collection<E>
        Specified by:
        add in interface Queue<E>
        Overrides:
        add in class AbstractQueue<E>
        Parameters:
        element - the element to add
        Returns:
        true always

      • addAll

        @CanIgnoreReturnValue
public boolean addAll​(Collection<? extends E> newElements)
        Description copied from class: java.util.AbstractQueue
        Adds all of the elements in the specified collection to this queue. Attempts to addAll of a queue to itself result in IllegalArgumentException. Further, the behavior of this operation is undefined if the specified collection is modified while the operation is in progress.

        This implementation iterates over the specified collection, and adds each element returned by the iterator to this queue, in turn. A runtime exception encountered while trying to add an element (including, in particular, a null element) may result in only some of the elements having been successfully added when the associated exception is thrown.

        Specified by:
        addAll in interface Collection<E>
        Overrides:
        addAll in class AbstractQueue<E>
        Parameters:
        newElements - collection containing elements to be added to this queue
        Returns:
        true if this queue changed as a result of the call
        See Also:
        AbstractQueue.add(Object)

      • offer

        @CanIgnoreReturnValue
public boolean offer​(E element)
        Adds the given element to this queue. If this queue has a maximum size, after adding element the queue will automatically evict its greatest element (according to its comparator), which may be element itself.
        Parameters:
        element - the element to add
        Returns:
        true if the element was added to this queue, else false

      • poll

        @CanIgnoreReturnValue
public E poll()
        Description copied from interface: java.util.Queue
        Retrieves and removes the head of this queue, or returns null if this queue is empty.
        Returns:
        the head of this queue, or null if this queue is empty

      • peek

        public E peek()
        Description copied from interface: java.util.Queue
        Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
        Returns:
        the head of this queue, or null if this queue is empty

      • peekFirst

        public E peekFirst()
        Retrieves, but does not remove, the least element of this queue, or returns null if the queue is empty.

      • peekLast

        public E peekLast()
        Retrieves, but does not remove, the greatest element of this queue, or returns null if the queue is empty.

      • iterator

        public Iterator<E> iterator()
        Returns an iterator over the elements contained in this collection, in no particular order.

        The iterator is fail-fast: If the MinMaxPriorityQueue is modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will generally throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

        Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

        Specified by:
        iterator in interface Collection<E>
        Specified by:
        iterator in interface Iterable<E>
        Specified by:
        iterator in class AbstractCollection<E>
        Returns:
        an iterator over the elements contained in this collection

      • clear

        public void clear()
        Description copied from class: java.util.AbstractQueue
        Removes all of the elements from this queue. The queue will be empty after this call returns.

        This implementation repeatedly invokes poll until it returns null.

        Specified by:
        clear in interface Collection<E>
        Overrides:
        clear in class AbstractQueue<E>

      • toArray

        public Object[] toArray()
        Description copied from class: java.util.AbstractCollection
        Returns an array containing all of the elements in this collection. If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. The returned array's runtime component type is Object.

        The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.

        Specified by:
        toArray in interface Collection<E>
        Overrides:
        toArray in class AbstractCollection<E>
        Returns:
        an array, whose runtime component type is Object, containing all of the elements in this collection