LinkedBlockingDeque

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractQueue<E>
  - - jsr166x.LinkedBlockingDeque<E>

Type Parameters:
E - the type of elements held in this collection

All Implemented Interfaces:

Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>, BlockingDeque<E>, Deque<E>
```
public class LinkedBlockingDeque<E>
extends AbstractQueue<E>
implements BlockingDeque<E>, Serializable
```
An optionally-bounded 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. This class is a member of the Java Collections Framework.

Since:

1.6

Author:

Doug Lea

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`LinkedBlockingDeque()` Creates a `LinkedBlockingDeque` with a capacity of `Integer.MAX_VALUE`.
`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.
`LinkedBlockingDeque(int capacity)` Creates a `LinkedBlockingDeque` with the given (fixed) capacity.

Method Summary

Methods
Modifier and Type	Method and Description
`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.
`void`	`addFirst(E e)` Inserts the specified element to the front of this deque unless it would violate capacity restrictions.
`void`	`addLast(E e)` Inserts the specified element to the end of this deque unless it would violate capacity restrictions.
`void`	`clear()` Atomically removes all of the elements from this deque.
`boolean`	`contains(Object o)` Returns `true` if this queue contains the specified element.
`int`	`drainTo(Collection<? super E> c)` Removes all available elements from this queue and adds them to the given collection.
`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.
`E`	`element()` Retrieves, but does not remove, the head of this queue.
`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)` Inserts the specified element into the queue represented by this deque unless it would violate capacity restrictions.
`boolean`	`offer(E o, long timeout, TimeUnit unit)` Inserts the specified element as the lest element of this deque, if possible.
`boolean`	`offerFirst(E o)` Inserts the specified element to the front this deque unless it would violate capacity restrictions.
`boolean`	`offerFirst(E o, long timeout, TimeUnit unit)` Inserts the specified element as the first element of this deque, waiting if necessary up to the specified wait time for space to become available.
`boolean`	`offerLast(E o)` Inserts the specified element to the end of this deque unless it would violate capacity restrictions.
`boolean`	`offerLast(E o, long timeout, TimeUnit unit)` Inserts the specified element as the last element of this deque, waiting if necessary up to the specified wait time for space to become available.
`E`	`peek()` Retrieves, but does not remove, the head of the queue represented by this deque, returning `null` if this deque is empty.
`E`	`peekFirst()` Retrieves, but does not remove, the first element of this deque, returning `null` if this deque is empty.
`E`	`peekLast()` Retrieves, but does not remove, the last element of this deque, returning `null` if this deque is empty.
`E`	`poll()` Retrieves and removes the head of the queue represented by this deque, or `null` if this deque is empty.
`E`	`poll(long timeout, TimeUnit unit)` Retrieves and removes the first element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque.
`E`	`pollFirst()` Retrieves and removes the first element of this deque, or `null` if this deque is empty.
`E`	`pollFirst(long timeout, TimeUnit unit)` Retrieves and removes the first element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque.
`E`	`pollLast()` Retrieves and removes the last element of this deque, or `null` if this deque is empty.
`E`	`pollLast(long timeout, TimeUnit unit)` Retrieves and removes the last element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque.
`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.
`void`	`put(E o)` Adds the specified element as the last element of this deque, waiting if necessary for space to become available.
`void`	`putFirst(E o)` Adds the specified element as the first element of this deque, waiting if necessary for space to become available.
`void`	`putLast(E o)` Adds the specified element as the last element of this deque, waiting if necessary for space to become available.
`int`	`remainingCapacity()` Returns the number of 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 this queue.
`boolean`	`remove(Object o)` Removes a single instance of the specified element from this queue, if it is present.
`E`	`removeFirst()` Removes and returns the first element of this deque.
`boolean`	`removeFirstOccurrence(Object e)` Removes the first occurrence of the specified element in this deque.
`E`	`removeLast()` Retrieves and removes the last element of this deque.
`boolean`	`removeLastOccurrence(Object e)` Removes the last occurrence of the specified element in this deque.
`int`	`size()` Returns the number of elements in this deque.
`E`	`take()` Retrieves and removes the first element of this deque, waiting if no elements are present on this deque.
`E`	`takeFirst()` Retrieves and removes the first element of this deque, waiting if no elements are present on this deque.
`E`	`takeLast()` Retrieves and removes the last element of this deque, waiting if no elements are present on this deque.
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`String`	`toString()`

Methods inherited from class java.util.AbstractQueue
addAll

Methods inherited from class java.util.AbstractCollection
containsAll, isEmpty, removeAll, retainAll

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection
addAll, containsAll, equals, hashCode, isEmpty, removeAll, retainAll

- Constructor Detail
  - LinkedBlockingDeque
```
public LinkedBlockingDeque()
```
    Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
  - LinkedBlockingDeque
```
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
  - LinkedBlockingDeque
```
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 c or any element within it is null
- Method Detail
  - offerFirst
```
public boolean offerFirst(E o)
```
    Description copied from interface: Deque
    
    Inserts the specified element to the front this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, this method is generally preferable to method addFirst, which can fail to insert an element only by throwing an exception.
    
    Specified by:
    
    offerFirst in interface Deque<E>
    
    Parameters:
    o - the element to insert
    
    Returns:
    true if it was possible to insert the element, else false
  - offerLast
```
public boolean offerLast(E o)
```
    Description copied from interface: Deque
    
    Inserts the specified element to the end of this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, this method is generally preferable to method addLast which can fail to insert an element only by throwing an exception.
    
    Specified by:
    
    offerLast in interface Deque<E>
    
    Parameters:
    o - the element to insert
    
    Returns:
    true if it was possible to insert the element, else false
  - addFirst
```
public void addFirst(E e)
```
    Description copied from interface: Deque
    
    Inserts the specified element to the front of this deque unless it would violate capacity restrictions.
    
    Specified by:
    
    addFirst in interface Deque<E>
    
    Parameters:
    e - the element to insert
  - addLast
```
public void addLast(E e)
```
    Description copied from interface: Deque
    
    Inserts the specified element to the end of this deque unless it would violate capacity restrictions.
    
    Specified by:
    
    addLast in interface Deque<E>
    
    Parameters:
    e - the element to insert
  - pollFirst
```
public E pollFirst()
```
    Description copied from interface: Deque
    
    Retrieves and removes the first element of this deque, or null if this deque is empty.
    
    Specified by:
    
    pollFirst in interface Deque<E>
    
    Returns:
    the first element of this deque, or null if this deque is empty
  - pollLast
```
public E pollLast()
```
    Description copied from interface: Deque
    
    Retrieves and removes the last element of this deque, or null if this deque is empty.
    
    Specified by:
    
    pollLast in interface Deque<E>
    
    Returns:
    the last element of this deque, or null if this deque is empty
  - removeFirst
```
public E removeFirst()
```
    Description copied from interface: Deque
    
    Removes and returns the first element of this deque. This method differs from the pollFirst method only in that it throws an exception if this deque is empty.
    
    Specified by:
    
    removeFirst in interface Deque<E>
    
    Returns:
    the first element of this deque
  - removeLast
```
public E removeLast()
```
    Description copied from interface: Deque
    
    Retrieves and removes the last element of this deque. This method differs from the pollLast method only in that it throws an exception if this deque is empty.
    
    Specified by:
    
    removeLast in interface Deque<E>
    
    Returns:
    the last element of this deque
  - peekFirst
```
public E peekFirst()
```
    Description copied from interface: Deque
    
    Retrieves, but does not remove, the first element of this deque, returning null if this deque is empty.
    
    Specified by:
    
    peekFirst in interface Deque<E>
    
    Returns:
    the first element of this deque, or null if this deque is empty
  - peekLast
```
public E peekLast()
```
    Description copied from interface: Deque
    
    Retrieves, but does not remove, the last element of this deque, returning null if this deque is empty.
    
    Specified by:
    
    peekLast in interface Deque<E>
    
    Returns:
    the last element of this deque, or null if this deque is empty
  - getFirst
```
public E getFirst()
```
    Description copied from interface: Deque
    
    Retrieves, but does not remove, the first element of this deque. This method differs from the peek method only in that it throws an exception if this deque is empty.
    
    Specified by:
    
    getFirst in interface Deque<E>
    
    Returns:
    the first element of this deque
  - getLast
```
public E getLast()
```
    Description copied from interface: Deque
    
    Retrieves, but does not remove, the last element of this deque. This method differs from the peek method only in that it throws an exception if this deque is empty.
    
    Specified by:
    
    getLast in interface Deque<E>
    
    Returns:
    the last element of this deque
  - putFirst
```
public void putFirst(E o)
              throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Adds the specified element as the first element of this deque, waiting if necessary for space to become available.
    
    Specified by:
    
    putFirst in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - putLast
```
public void putLast(E o)
             throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Adds the specified element as the last element of this deque, waiting if necessary for space to become available.
    
    Specified by:
    
    putLast in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - takeFirst
```
public E takeFirst()
            throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the first element of this deque, waiting if no elements are present on this deque.
    
    Specified by:
    
    takeFirst in interface BlockingDeque<E>
    
    Returns:
    the head of this deque
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - takeLast
```
public E takeLast()
           throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the last element of this deque, waiting if no elements are present on this deque.
    
    Specified by:
    
    takeLast in interface BlockingDeque<E>
    
    Returns:
    the head of this deque
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - offerFirst
```
public boolean offerFirst(E o,
                 long timeout,
                 TimeUnit unit)
                   throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Inserts the specified element as the first element of this deque, waiting if necessary up to the specified wait time for space to become available.
    
    Specified by:
    
    offerFirst in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    true if successful, or false if the specified waiting time elapses before space is available.
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - offerLast
```
public boolean offerLast(E o,
                long timeout,
                TimeUnit unit)
                  throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Inserts the specified element as the last element of this deque, waiting if necessary up to the specified wait time for space to become available.
    
    Specified by:
    
    offerLast in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    true if successful, or false if the specified waiting time elapses before space is available.
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - pollFirst
```
public E pollFirst(long timeout,
          TimeUnit unit)
            throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the first element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque.
    
    Specified by:
    
    pollFirst in interface BlockingDeque<E>
    
    Parameters:
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    the head of this deque, or null if the specified waiting time elapses before an element is present.
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - pollLast
```
public E pollLast(long timeout,
         TimeUnit unit)
           throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the last element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque.
    
    Specified by:
    
    pollLast in interface BlockingDeque<E>
    
    Parameters:
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    the head of this deque, or null if the specified waiting time elapses before an element is present.
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - offer
```
public boolean offer(E e)
```
    Description copied from interface: Deque
    
    Inserts the specified element into the queue represented by this deque unless it would violate capacity restrictions. In other words, inserts the specified element to the end of this deque. When using a capacity-restricted deque, this method is generally preferable to the Deque.add(E) method, which can fail to insert an element only by throwing an exception.
    This method is equivalent to Deque.offerLast(E).
    
    Specified by:
    
    offer in interface BlockingQueue<E>
    
    Specified by:
    
    offer in interface Queue<E>
    
    Specified by:
    
    offer in interface Deque<E>
    
    Parameters:
    e - the element to insert
    
    Returns:
    true if it was possible to insert the element, else false
  - add
```
public boolean add(E e)
```
    Description copied from class: java.util.AbstractQueue
    
    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.
    
    Specified by:
    
    add in interface Collection<E>
    
    Specified by:
    
    add in interface BlockingQueue<E>
    
    Specified by:
    
    add in interface Queue<E>
    
    Specified by:
    
    add in interface Deque<E>
    
    Overrides:
    
    add in class AbstractQueue<E>
    
    Parameters:
    e - the element to add
    
    Returns:
    true (as specified by Collection.add(E))
  - push
```
public void push(E e)
```
    Description copied from interface: Deque
    
    Pushes an element onto the stack represented by this deque. In other words, inserts the element to the front this deque unless it would violate capacity restrictions.
    This method is equivalent to Deque.addFirst(E).
    
    Specified by:
    
    push in interface Deque<E>
  - poll
```
public E poll()
```
    Description copied from interface: Deque
    
    Retrieves and removes the head of the queue represented by this deque, or null if this deque is empty. In other words, retrieves and removes the first element of this deque, or null if this deque is empty.
    This method is equivalent to Deque.pollFirst().
    
    Specified by:
    
    poll in interface Queue<E>
    
    Specified by:
    
    poll in interface Deque<E>
    
    Returns:
    the first element of this deque, or null if this deque is empty
  - remove
```
public E remove()
```
    Description copied from class: java.util.AbstractQueue
    
    Retrieves and removes the head of this queue. This method differs from 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.
    
    Specified by:
    
    remove in interface Queue<E>
    
    Specified by:
    
    remove in interface Deque<E>
    
    Overrides:
    
    remove in class AbstractQueue<E>
    
    Returns:
    the head of this queue
  - pop
```
public E pop()
```
    Description copied from interface: Deque
    
    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 Deque.removeFirst().
    
    Specified by:
    
    pop in interface Deque<E>
    
    Returns:
    the element at the front of this deque (which is the top of the stack represented by this deque)
  - peek
```
public E peek()
```
    Description copied from interface: Deque
    
    Retrieves, but does not remove, the head of the queue represented by this deque, returning null if this deque is empty.
    This method is equivalent to Deque.peekFirst()
    
    Specified by:
    
    peek in interface Queue<E>
    
    Specified by:
    
    peek in interface Deque<E>
    
    Returns:
    the head of the queue represented by this deque, or null if this deque is empty
  - element
```
public E element()
```
    Description copied from class: java.util.AbstractQueue
    
    Retrieves, but does not remove, the head of this queue. This method differs from 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.
    
    Specified by:
    
    element in interface Queue<E>
    
    Specified by:
    
    element in interface Deque<E>
    
    Overrides:
    
    element in class AbstractQueue<E>
    
    Returns:
    the head of this queue
  - remove
```
public boolean remove(Object o)
```
    Description copied from interface: java.util.concurrent.BlockingQueue
    
    Removes a single instance of the specified element from this queue, if it is present. More formally, removes an element e such that o.equals(e), if this queue contains one or more such elements. Returns true if this queue contained the specified element (or equivalently, if this queue changed as a result of the call).
    
    Specified by:
    
    remove in interface Collection<E>
    
    Specified by:
    
    remove in interface BlockingQueue<E>
    
    Overrides:
    
    remove in class AbstractCollection<E>
    
    Parameters:
    o - element to be removed from this queue, if present
    
    Returns:
    true if this queue changed as a result of the call
  - put
```
public void put(E o)
         throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Adds the specified element as the last element of this deque, waiting if necessary for space to become available. This method is equivalent to putLast
    
    Specified by:
    
    put in interface BlockingQueue<E>
    
    Specified by:
    
    put in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - take
```
public E take()
       throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the first element of this deque, waiting if no elements are present on this deque. This method is equivalent to takeFirst
    
    Specified by:
    
    take in interface BlockingQueue<E>
    
    Specified by:
    
    take in interface BlockingDeque<E>
    
    Returns:
    the head of this deque
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - offer
```
public boolean offer(E o,
            long timeout,
            TimeUnit unit)
              throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Inserts the specified element as the lest element of this deque, if possible. When using deques that may impose insertion restrictions (for example capacity bounds), method offer is generally preferable to method Collection.add(E), which can fail to insert an element only by throwing an exception. This method is equivalent to offerLast
    
    Specified by:
    
    offer in interface BlockingQueue<E>
    
    Specified by:
    
    offer in interface BlockingDeque<E>
    
    Parameters:
    o - the element to add.
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    true if it was possible to add the element to this deque, else false
    
    Throws:
    
    InterruptedException - if interrupted while waiting
  - poll
```
public E poll(long timeout,
     TimeUnit unit)
       throws InterruptedException
```
    Description copied from interface: BlockingDeque
    
    Retrieves and removes the first element of this deque, waiting if necessary up to the specified wait time if no elements are present on this deque. This method is equivalent to pollFirst
    
    Specified by:
    
    poll in interface BlockingQueue<E>
    
    Specified by:
    
    poll in interface BlockingDeque<E>
    
    Parameters:
    timeout - how long to wait before giving up, in units of unit
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    the head of this deque, or null if the specified waiting time elapses before an element is present.
    
    Throws:
    
    InterruptedException - if interrupted while waiting.
  - size
```
public int size()
```
    Returns the number of elements in this deque.
    
    Specified by:
    
    size in interface Collection<E>
    
    Specified by:
    
    size in class AbstractCollection<E>
    
    Returns:
    the number of elements in this deque.
  - remainingCapacity
```
public int remainingCapacity()
```
    Returns the number of elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking. This is always equal to the initial capacity of this deque less the current size of this deque.
    Note that you cannot always tell if an attempt to add an element will succeed by inspecting remainingCapacity because it may be the case that a waiting consumer is ready to take an element out of an otherwise full deque.
    
    Specified by:
    
    remainingCapacity in interface BlockingQueue<E>
    
    Returns:
    the remaining capacity
  - contains
```
public boolean contains(Object o)
```
    Description copied from interface: java.util.concurrent.BlockingQueue
    
    Returns true if this queue contains the specified element. More formally, returns true if and only if this queue contains at least one element e such that o.equals(e).
    
    Specified by:
    
    contains in interface Collection<E>
    
    Specified by:
    
    contains in interface BlockingQueue<E>
    
    Overrides:
    
    contains in class AbstractCollection<E>
    
    Parameters:
    o - object to be checked for containment in this queue
    
    Returns:
    true if this queue contains the specified element
  - removeFirstOccurrence
```
public boolean removeFirstOccurrence(Object e)
```
    Description copied from interface: Deque
    
    Removes the first occurrence of the specified element in 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).
    
    Specified by:
    
    removeFirstOccurrence in interface Deque<E>
    
    Parameters:
    e - element to be removed from this deque, if present
    
    Returns:
    true if the deque contained the specified element
  - removeLastOccurrence
```
public boolean removeLastOccurrence(Object e)
```
    Description copied from interface: Deque
    
    Removes the last occurrence of the specified element in 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).
    
    Specified by:
    
    removeLastOccurrence in interface Deque<E>
    
    Parameters:
    e - element to be removed from this deque, if present
    
    Returns:
    true if the deque contained the specified element
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<E>
    
    Overrides:
    
    toArray in class AbstractCollection<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<E>
    
    Overrides:
    
    toArray in class AbstractCollection<E>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractCollection<E>
  - clear
```
public void clear()
```
    Atomically removes all of the elements from this deque. The deque will be empty after this call returns.
    
    Specified by:
    
    clear in interface Collection<E>
    
    Overrides:
    
    clear in class AbstractQueue<E>
  - drainTo
```
public int drainTo(Collection<? super E> c)
```
    Description copied from interface: java.util.concurrent.BlockingQueue
    
    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.
    
    Specified by:
    
    drainTo in interface BlockingQueue<E>
    
    Parameters:
    c - the collection to transfer elements into
    
    Returns:
    the number of elements transferred
  - drainTo
```
public int drainTo(Collection<? super E> c,
          int maxElements)
```
    Description copied from interface: java.util.concurrent.BlockingQueue
    
    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.
    
    Specified by:
    
    drainTo in interface BlockingQueue<E>
    
    Parameters:
    c - the collection to transfer elements into
    maxElements - the maximum number of elements to transfer
    
    Returns:
    the number of elements transferred
  - iterator
```
public Iterator<E> iterator()
```
    Returns an iterator over the elements in this deque in proper sequence. The returned Iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
    
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface Collection<E>
    
    Specified by:
    
    iterator in interface Deque<E>
    
    Specified by:
    
    iterator in class AbstractCollection<E>
    
    Returns:
    an iterator over the elements in this deque in proper sequence.

Class LinkedBlockingDeque<E>

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractQueue

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Constructor Detail

LinkedBlockingDeque

LinkedBlockingDeque

LinkedBlockingDeque

Method Detail

offerFirst

offerLast

addFirst

addLast

pollFirst

pollLast

removeFirst

removeLast

peekFirst

peekLast

getFirst

getLast

putFirst

putLast

takeFirst

takeLast

offerFirst

offerLast

pollFirst

pollLast

offer

add

push

poll

remove

pop

peek

element

remove

put

take

offer

poll

size

remainingCapacity

contains

removeFirstOccurrence

removeLastOccurrence

toArray

toArray

toString

clear

drainTo

drainTo

iterator