AbstractQueuepublic abstract class AbstractQueue extends AbstractCollection implements QueueThis class provides skeletal implementations of some {@link Queue}
operations. The implementations in this class are appropriate when
the base implementation does not allow null
elements. Methods {@link #add add}, {@link #remove remove}, and
{@link #element element} are based on {@link #offer offer}, {@link
#poll poll}, and {@link #peek peek}, respectively but throw
exceptions instead of indicating failure via false or
null returns.
A Queue implementation that extends this class must
minimally define a method {@link Queue#offer} which does not permit
insertion of null elements, along with methods {@link
Queue#peek}, {@link Queue#poll}, {@link Collection#size}, and a
{@link Collection#iterator} supporting {@link
Iterator#remove}. Typically, additional methods will be overridden
as well. If these requirements cannot be met, consider instead
subclassing {@link AbstractCollection}.
This class is a member of the
Java Collections Framework. |
Constructors Summary |
---|
protected AbstractQueue()Constructor for use by subclasses.
|
Methods Summary |
---|
public boolean | add(E e)Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an IllegalStateException
if no space is currently available.
This implementation returns true if offer succeeds,
else throws an IllegalStateException.
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
| public boolean | addAll(java.util.Collection c)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.
if (c == null)
throw new NullPointerException();
if (c == this)
throw new IllegalArgumentException();
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))
modified = true;
}
return modified;
| public void | clear()Removes all of the elements from this queue.
The queue will be empty after this call returns.
This implementation repeatedly invokes {@link #poll poll} until it
returns null.
while (poll() != null)
;
| public E | element()Retrieves, but does not remove, the head of this queue. This method
differs from {@link #peek peek} only in that it throws an exception if
this queue is empty.
This implementation returns the result of peek
unless the queue is empty.
E x = peek();
if (x != null)
return x;
else
throw new NoSuchElementException();
| public E | remove()Retrieves and removes the head of this queue. This method differs
from {@link #poll poll} only in that it throws an exception if this
queue is empty.
This implementation returns the result of poll
unless the queue is empty.
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
|
|