* This interface defines methods to access the elements at both ends of the deque. Methods are provided to insert, * remove, and examine the element. Each of these methods exists in two forms: one throws an exception if the operation * fails, the other returns a special value (either null or false, depending on the operation). The * latter form of the insert operation is designed specifically for use with capacity-restricted Deque * implementations; in most implementations, insert operations cannot fail. * *
* The twelve methods described above are summarized in the following table: * *
*
| * | First Element (Head) | *Last Element (Tail) | *||
| * | Throws exception | *Special value | *Throws exception | *Special value | *
| Insert | *{@link #addFirst addFirst(e)} | *{@link #offerFirst offerFirst(e)} | *{@link #addLast addLast(e)} | *{@link #offerLast offerLast(e)} | *
| Remove | *{@link #removeFirst removeFirst()} | *{@link #pollFirst pollFirst()} | *{@link #removeLast removeLast()} | *{@link #pollLast pollLast()} | *
| Examine | *{@link #getFirst getFirst()} | *{@link #peekFirst peekFirst()} | *{@link #getLast getLast()} | *{@link #peekLast peekLast()} | *
* This interface extends the {@link Queue} interface. When a deque is used as a queue, FIFO (First-In-First-Out) * behavior results. Elements are added at the end of the deque and removed from the beginning. The methods inherited * from the Queue interface are precisely equivalent to Deque methods as indicated in the following * table: * *
*
| Queue Method | *Equivalent Deque Method | *
| {@link java.util.Queue#add add(e)} | *{@link #addLast addLast(e)} | *
| {@link java.util.Queue#offer offer(e)} | *{@link #offerLast offerLast(e)} | *
| {@link java.util.Queue#remove remove()} | *{@link #removeFirst removeFirst()} | *
| {@link java.util.Queue#poll poll()} | *{@link #pollFirst pollFirst()} | *
| {@link java.util.Queue#element element()} | *{@link #getFirst getFirst()} | *
| {@link java.util.Queue#peek peek()} | *{@link #peek peekFirst()} | *
* Deques can also be used as LIFO (Last-In-First-Out) stacks. This interface should be used in preference to the legacy * {@link Stack} class. When a deque is used as a stack, elements are pushed and popped from the beginning of the deque. * Stack methods are precisely equivalent to Deque methods as indicated in the table below: * *
*
| Stack Method | *Equivalent Deque Method | *
| {@link #push push(e)} | *{@link #addFirst addFirst(e)} | *
| {@link #pop pop()} | *{@link #removeFirst removeFirst()} | *
| {@link #peek peek()} | *{@link #peekFirst peekFirst()} | *
* Note that the {@link #peek peek} method works equally well when a deque is used as a queue or a stack; in either * case, elements are drawn from the beginning of the deque. * *
* This interface provides two methods to remove interior elements, {@link #removeFirstOccurrence removeFirstOccurrence} * and {@link #removeLastOccurrence removeLastOccurrence}. * *
* Unlike the {@link List} interface, this interface does not provide support for indexed access to elements. * *
* While Deque implementations are not strictly required to prohibit the insertion of null elements, they are * strongly encouraged to do so. Users of any Deque implementations that do allow null elements are strongly * encouraged not to take advantage of the ability to insert nulls. This is so because null is used as a * special return value by various methods to indicated that the deque is empty. * *
* Deque implementations generally do not define element-based versions of the equals and * hashCode methods, but instead inherit the identity-based versions from class Object. * *
* This interface is a member of the Java Collections
* Framework.
*
* @author Doug Lea
* @author Josh Bloch
* @since 1.6
* @param
* This method is equivalent to {@link #add}.
*
* @param e
* the element to add
* @throws IllegalStateException
* if the element cannot be added at this time due to capacity restrictions
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
void addLast(E e);
/**
* Inserts the specified element at the front of this deque unless it would violate capacity restrictions. When
* using a capacity-restricted deque, this method is generally preferable to the {@link #addFirst} method, which can
* fail to insert an element only by throwing an exception.
*
* @param e
* the element to add
* @return true if the element was added to this deque, else false
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
boolean offerFirst(E e);
/**
* Inserts the specified element at the end of this deque unless it would violate capacity restrictions. When using
* a capacity-restricted deque, this method is generally preferable to the {@link #addLast} method, which can fail
* to insert an element only by throwing an exception.
*
* @param e
* the element to add
* @return true if the element was added to this deque, else false
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
boolean offerLast(E e);
/**
* Retrieves and removes the first element of this deque. This method differs from {@link #pollFirst pollFirst} only
* in that it throws an exception if this deque is empty.
*
* @return the head of this deque
* @throws NoSuchElementException
* if this deque is empty
*/
E removeFirst();
/**
* Retrieves and removes the last element of this deque. This method differs from {@link #pollLast pollLast} only in
* that it throws an exception if this deque is empty.
*
* @return the tail of this deque
* @throws NoSuchElementException
* if this deque is empty
*/
E removeLast();
/**
* Retrieves and removes the first element of this deque, or returns null if this deque is empty.
*
* @return the head of this deque, or null if this deque is empty
*/
@Nullable
E pollFirst();
/**
* Retrieves and removes the last element of this deque, or returns null if this deque is empty.
*
* @return the tail of this deque, or null if this deque is empty
*/
@Nullable
E pollLast();
/**
* Retrieves, but does not remove, the first element of this deque.
*
* This method differs from {@link #peekFirst peekFirst} only in that it throws an exception if this deque is empty.
*
* @return the head of this deque
* @throws NoSuchElementException
* if this deque is empty
*/
E getFirst();
/**
* Retrieves, but does not remove, the last element of this deque. This method differs from {@link #peekLast
* peekLast} only in that it throws an exception if this deque is empty.
*
* @return the tail of this deque
* @throws NoSuchElementException
* if this deque is empty
*/
E getLast();
/**
* Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.
*
* @return the head of this deque, or null if this deque is empty
*/
@Nullable
E peekFirst();
/**
* Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.
*
* @return the tail of this deque, or null if this deque is empty
*/
@Nullable
E peekLast();
/**
* Removes the first occurrence of the specified element from this deque. If the deque does not contain the element,
* it is unchanged. More formally, removes the first element e such that
* (o==null ? e==null : o.equals(e)) (if such an element exists). Returns true
* if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
*
* @param o
* element to be removed from this deque, if present
* @return true if an element was removed as a result of this call
* @throws ClassCastException
* if the class of the specified element is incompatible with this deque
* (optional)
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* (optional)
*/
boolean removeFirstOccurrence(Object o);
/**
* Removes the last occurrence of the specified element from this deque. If the deque does not contain the element,
* it is unchanged. More formally, removes the last element e such that
* (o==null ? e==null : o.equals(e)) (if such an element exists). Returns true
* if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
*
* @param o
* element to be removed from this deque, if present
* @return true if an element was removed as a result of this call
* @throws ClassCastException
* if the class of the specified element is incompatible with this deque
* (optional)
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* (optional)
*/
boolean removeLastOccurrence(Object o);
// *** Queue methods ***
/**
* Inserts the specified element into the queue represented by this deque (in other words, at the tail of this
* deque) 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. When using a
* capacity-restricted deque, it is generally preferable to use {@link #offer(Object) offer}.
*
*
* This method is equivalent to {@link #addLast}.
*
* @param e
* the element to add
* @return true (as specified by {@link Collection#add})
* @throws IllegalStateException
* if the element cannot be added at this time due to capacity restrictions
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
@Override
boolean add(E e);
/**
* Inserts the specified element into the queue represented by this deque (in other words, at the tail of this
* deque) if it is possible to do so immediately without violating capacity restrictions, returning true
* upon success and false if no space is currently available. When using a capacity-restricted deque, this
* method is generally preferable to the {@link #add} method, which can fail to insert an element only by throwing
* an exception.
*
*
* This method is equivalent to {@link #offerLast}.
*
* @param e
* the element to add
* @return true if the element was added to this deque, else false
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
@Override
boolean offer(E e);
/**
* Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this
* deque). This method differs from {@link #poll poll} only in that it throws an exception if this deque is empty.
*
*
* This method is equivalent to {@link #removeFirst()}.
*
* @return the head of the queue represented by this deque
* @throws NoSuchElementException
* if this deque is empty
*/
@Override
E remove();
/**
* Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this
* deque), or returns null if this deque is empty.
*
*
* This method is equivalent to {@link #pollFirst()}.
*
* @return the first element of this deque, or null if this deque is empty
*/
@Override
@Nullable
E poll();
/**
* Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first
* element of this deque). This method differs from {@link #peek peek} only in that it throws an exception if this
* deque is empty.
*
*
* This method is equivalent to {@link #getFirst()}.
*
* @return the head of the queue represented by this deque
* @throws NoSuchElementException
* if this deque is empty
*/
@Override
E element();
/**
* Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first
* element of this deque), or returns null if this deque is empty.
*
*
* This method is equivalent to {@link #peekFirst()}.
*
* @return the head of the queue represented by this deque, or null if this deque is empty
*/
@Override
@Nullable
E peek();
// *** Stack methods ***
/**
* Pushes an element onto the stack represented by this deque (in other words, at the head of this deque) 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 method is equivalent to {@link #addFirst}.
*
* @param e
* the element to push
* @throws IllegalStateException
* if the element cannot be added at this time due to capacity restrictions
* @throws ClassCastException
* if the class of the specified element prevents it from being added to this deque
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* @throws IllegalArgumentException
* if some property of the specified element prevents it from being added to this deque
*/
void push(E e);
/**
* Pops an element from the stack represented by this deque. In other words, removes and returns the first element
* of this deque.
*
*
* This method is equivalent to {@link #removeFirst()}.
*
* @return the element at the front of this deque (which is the top of the stack represented by this deque)
* @throws NoSuchElementException
* if this deque is empty
*/
E pop();
// *** Collection methods ***
/**
* Removes the first occurrence of the specified element from this deque. If the deque does not contain the element,
* it is unchanged. More formally, removes the first element e such that
* (o==null ? e==null : o.equals(e)) (if such an element exists). Returns true
* if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
*
*
* This method is equivalent to {@link #removeFirstOccurrence}.
*
* @param o
* element to be removed from this deque, if present
* @return true if an element was removed as a result of this call
* @throws ClassCastException
* if the class of the specified element is incompatible with this deque
* (optional)
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* (optional)
*/
@Override
boolean remove(Object o);
/**
* Returns true if this deque contains the specified element. More formally, returns true if and
* only if this deque contains at least one element e such that
* (o==null ? e==null : o.equals(e)).
*
* @param o
* element whose presence in this deque is to be tested
* @return true if this deque contains the specified element
* @throws ClassCastException
* if the type of the specified element is incompatible with this deque
* (optional)
* @throws NullPointerException
* if the specified element is null and this deque does not permit null elements
* (optional)
*/
@Override
boolean contains(Object o);
/**
* Returns the number of elements in this deque.
*
* @return the number of elements in this deque
*/
@Override
public int size();
/**
* Returns an iterator over the elements in this deque in proper sequence. The elements will be returned in order
* from first (head) to last (tail).
*
* @return an iterator over the elements in this deque in proper sequence
*/
@Override
Iterator