AbstractQueuepublic abstract class AbstractQueue extends AbstractCollection implements Queue| This 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 o)Adds the specified element to this queue. This implementation
returns true if offer succeeds, else
throws an IllegalStateException.
if (offer(o))
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
collection, 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 collection.
The collection 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 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 implementation returns the result of poll
unless the queue is empty.
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
|
|
