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 | |
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 | |
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 | |
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 | |
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 | |
E | |
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 | |
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 (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
true
(as specified byCollection.add(E)
)
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
Throws
NoSuchElementException |
---|
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
Throws
NoSuchElementException |
---|
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