LinkedBlockingDeque

public class LinkedBlockingDeque extends AbstractQueue<E>
implements BlockingDeque<E> Serializable

An optionally-bounded {@linkplain BlockingDeque blocking deque} based on linked nodes.

The optional capacity bound constructor argument serves as a way to prevent excessive expansion. The capacity, if unspecified, is equal to Integer.MAX_VALUE. Linked nodes are dynamically created upon each insertion unless this would bring the deque above capacity.

Most operations run in constant time (ignoring time spent blocking). Exceptions include remove, removeFirstOccurrence, removeLastOccurrence, contains, iterator.remove(), and the bulk operations, all of which run in linear time.

This class and its iterator implement all of the optional methods of the Collection and Iterator interfaces.

Public Constructor Summary

LinkedBlockingDeque()
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
LinkedBlockingDeque(int capacity)
Creates a LinkedBlockingDeque with the given (fixed) capacity.
LinkedBlockingDeque(Collection<? extends E> c)
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.

Public Method Summary

boolean
add(E e)
Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
void
addFirst(E e)
Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.
void
addLast(E e)
Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.
void
clear()
Atomically removes all of the elements from this deque.
boolean
contains(Object o)
Returns true if this deque contains the specified element.
Iterator<E>
descendingIterator()
Returns an iterator over the elements in this deque in reverse sequential order.
int
drainTo(Collection<? super E> c, int maxElements)
Removes at most the given number of available elements from this queue and adds them to the given collection.
int
drainTo(Collection<? super E> c)
Removes all available elements from this queue and adds them to the given collection.
E
element()
Retrieves, but does not remove, the head of the queue represented by this deque.
E
getFirst()
Retrieves, but does not remove, the first element of this deque.
E
getLast()
Retrieves, but does not remove, the last element of this deque.
Iterator<E>
iterator()
Returns an iterator over the elements in this deque in proper sequence.
boolean
offer(E e, long timeout, TimeUnit unit)
Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting up to the specified wait time if necessary for space to become available.
boolean
offer(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.
boolean
offerFirst(E e)
Inserts the specified element at the front 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.
boolean
offerFirst(E e, long timeout, TimeUnit unit)
Inserts the specified element at the front of this deque, waiting up to the specified wait time if necessary for space to become available.
boolean
offerLast(E e)
Inserts the specified element at the end 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.
boolean
offerLast(E e, long timeout, TimeUnit unit)
Inserts the specified element at the end of this deque, waiting up to the specified wait time if necessary for space to become available.
E
peek()
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.
E
peekFirst()
Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.
E
peekLast()
Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.
E
poll(long timeout, TimeUnit unit)
Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting up to the specified wait time if necessary for an element to become available.
E
poll()
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.
E
pollFirst()
Retrieves and removes the first element of this deque, or returns null if this deque is empty.
E
pollFirst(long timeout, TimeUnit unit)
Retrieves and removes the first element of this deque, waiting up to the specified wait time if necessary for an element to become available.
E
pollLast(long timeout, TimeUnit unit)
Retrieves and removes the last element of this deque, waiting up to the specified wait time if necessary for an element to become available.
E
pollLast()
Retrieves and removes the last element of this deque, or returns null if this deque is empty.
E
pop()
Pops an element from the stack represented by this deque.
void
push(E e)
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, throwing an IllegalStateException if no space is currently available.
void
put(E e)
Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting if necessary for space to become available.
void
putFirst(E e)
Inserts the specified element at the front of this deque, waiting if necessary for space to become available.
void
putLast(E e)
Inserts the specified element at the end of this deque, waiting if necessary for space to become available.
int
remainingCapacity()
Returns the number of additional elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking.
E
remove()
Retrieves and removes the head of the queue represented by this deque.
boolean
remove(Object o)
Removes the first occurrence of the specified element from this deque.
E
removeFirst()
Retrieves and removes the first element of this deque.
boolean
removeFirstOccurrence(Object o)
Removes the first occurrence of the specified element from this deque.
E
removeLast()
Retrieves and removes the last element of this deque.
boolean
removeLastOccurrence(Object o)
Removes the last occurrence of the specified element from this deque.
int
size()
Returns the number of elements in this deque.
Spliterator<E>
spliterator()
Returns a Spliterator over the elements in this deque.
E
take()
Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting if necessary until an element becomes available.
E
takeFirst()
Retrieves and removes the first element of this deque, waiting if necessary until an element becomes available.
E
takeLast()
Retrieves and removes the last element of this deque, waiting if necessary until an element becomes available.
Object[]
toArray()
Returns an array containing all of the elements in this deque, in proper sequence (from first to last element).
<T> T[]
toArray(T[] a)
Returns an array containing all of the elements in this deque, in proper sequence; the runtime type of the returned array is that of the specified array.
String
toString()
Returns a string representation of this collection.

Inherited Method Summary

Public Constructors

public LinkedBlockingDeque ()

Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.

public LinkedBlockingDeque (int capacity)

Creates a LinkedBlockingDeque with the given (fixed) capacity.

Parameters
capacity the capacity of this deque
Throws
IllegalArgumentException if capacity is less than 1

public LinkedBlockingDeque (Collection<? extends E> c)

Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.

Parameters
c the collection of elements to initially contain
Throws
NullPointerException if the specified collection or any of its elements are null

Public Methods

public boolean add (E e)

Inserts the specified element at the end of this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, it is generally preferable to use method offer.

This method is equivalent to addLast(E).

Parameters
e the element to add
Returns
Throws
IllegalStateException if this deque is full
NullPointerException if the specified element is null

public void addFirst (E e)

Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available. When using a capacity-restricted deque, it is generally preferable to use offerFirst.

Parameters
e the element to add
Throws
IllegalStateException if this deque is full
NullPointerException

public void addLast (E e)

Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available. When using a capacity-restricted deque, it is generally preferable to use offerLast.

Parameters
e the element to add
Throws
IllegalStateException if this deque is full
NullPointerException

public void clear ()

Atomically removes all of the elements from this deque. The deque will be empty after this call returns.

public boolean contains (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.equals(e).

Parameters
o object to be checked for containment in this deque
Returns
  • true if this deque contains the specified element

public Iterator<E> descendingIterator ()

Returns an iterator over the elements in this deque in reverse sequential order. The elements will be returned in order from last (tail) to first (head).

The returned iterator is weakly consistent.

Returns
  • an iterator over the elements in this deque in reverse order

public int drainTo (Collection<? super E> c, int maxElements)

Removes at most the given number of available elements from this queue and adds them to the given collection. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain 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.

Parameters
c the collection to transfer elements into
maxElements the maximum number of elements to transfer
Returns
  • the number of elements transferred

public int drainTo (Collection<? super E> c)

Removes all available elements from this queue and adds them to the given collection. This operation may be more efficient than repeatedly polling this queue. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain 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.

Parameters
c the collection to transfer elements into
Returns
  • the number of elements transferred

public E element ()

Retrieves, but does not remove, the head of the queue represented by this deque. This method differs from peek only in that it throws an exception if this deque is empty.

This method is equivalent to getFirst.

Returns
  • the head of the queue represented by this deque
Throws
NoSuchElementException if this deque is empty

public E getFirst ()

Retrieves, but does not remove, the first element of this deque. This method differs from peekFirst only in that it throws an exception if this deque is empty.

Returns
  • the head of this deque

public E getLast ()

Retrieves, but does not remove, the last element of this deque. This method differs from peekLast only in that it throws an exception if this deque is empty.

Returns
  • the tail of this deque

public Iterator<E> iterator ()

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).

The returned iterator is weakly consistent.

Returns
  • an iterator over the elements in this deque in proper sequence