| |
|
| java.util.concurrent.LinkedBlockingDeque
| Inner Class :final static class Node | |
| Method Summary | |
| public boolean | add(E e)
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions. | | public void | addFirst(E e)
| | public void | addLast(E e)
| | public void | clear()
Atomically removes all of the elements from this deque. | | public boolean | contains(Object o)
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. | | public int | drainTo(Collection<? super E> c)
| | public int | drainTo(Collection<? super E> c, int maxElements)
| | public E | element()
Retrieves, but does not remove, the head of the queue represented by
this deque. | | public E | getFirst()
| | public E | getLast()
| | public Iterator<E> | iterator()
Returns an iterator over the elements in this deque in proper sequence. | | public boolean | offer(E e)
| | public boolean | offer(E e, long timeout, TimeUnit unit)
| | public boolean | offerFirst(E e)
| | public boolean | offerFirst(E e, long timeout, TimeUnit unit)
| | public boolean | offerLast(E e)
| | public boolean | offerLast(E e, long timeout, TimeUnit unit)
| | public E | peek()
| | public E | peekFirst()
| | public E | peekLast()
| | public E | poll()
| | public E | poll(long timeout, TimeUnit unit)
| | public E | pollFirst()
| | public E | pollFirst(long timeout, TimeUnit unit)
| | public E | pollLast()
| | public E | pollLast(long timeout, TimeUnit unit)
| | public E | pop()
| | public void | push(E e)
| | public void | put(E e)
| | public void | putFirst(E e)
| | public void | putLast(E e)
| | public int | remainingCapacity()
Returns the number of additional elements that this deque can ideally
(in the absence of memory or resource constraints) accept without
blocking. | | public E | remove()
Retrieves and removes the head of the queue represented by this deque. | | public boolean | remove(Object o)
Removes the first occurrence of the specified element from this deque. | | public E | removeFirst()
| | public boolean | removeFirstOccurrence(Object o)
| | public E | removeLast()
| | public boolean | removeLastOccurrence(Object o)
| | boolean | removeNode(Node<E> e)
Variant of removeFirstOccurrence needed by iterator.remove. | | public int | size()
Returns the number of elements in this deque. | | public E | take()
| | public E | takeFirst()
| | public E | takeLast()
| | public Object[] | toArray()
Returns an array containing all of the elements in this deque, in
proper sequence (from first to last element).
The returned array will be "safe" in that no references to it are
maintained by this deque. | | public 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. | | public String | toString()
|
| LinkedBlockingDeque | | public LinkedBlockingDeque()(Code) | | Creates a LinkedBlockingDeque with a capacity of
Integer.MAX_VALUE .
|
| LinkedBlockingDeque | | public LinkedBlockingDeque(int capacity)(Code) | | 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)(Code) | | 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 anyof its elements are null |
| clear | | public void clear()(Code) | | Atomically removes all of the elements from this deque.
The deque will be empty after this call returns.
|
| contains | | public boolean contains(Object o)(Code) | | 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 true if this deque contains the specified element |
| descendingIterator | | public Iterator<E> descendingIterator()(Code) | | 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 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.
|
| iterator | | public Iterator<E> iterator()(Code) | | 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 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.
an iterator over the elements in this deque in proper sequence |
| peekFirst | | public E peekFirst()(Code) | | |
| peekLast | | public E peekLast()(Code) | | |
| pollFirst | | public E pollFirst()(Code) | | |
| pollLast | | public E pollLast()(Code) | | |
| remainingCapacity | | public int remainingCapacity()(Code) | | Returns the number of additional 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 insert
an element will succeed by inspecting remainingCapacity
because it may be the case that another thread is about to
insert or remove an element.
|
| remove | | public boolean remove(Object o)(Code) | | 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.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
LinkedBlockingDeque.removeFirstOccurrence(Object) removeFirstOccurrence .
Parameters:
o - element to be removed from this deque, if present true if this deque changed as a result of the call |
| removeFirstOccurrence | | public boolean removeFirstOccurrence(Object o)(Code) | | |
| removeLastOccurrence | | public boolean removeLastOccurrence(Object o)(Code) | | |
| removeNode | | boolean removeNode(Node<E> e)(Code) | | Variant of removeFirstOccurrence needed by iterator.remove.
Searches for the node, not its contents.
|
| size | | public int size()(Code) | | Returns the number of elements in this deque.
the number of elements in this deque |
| toArray | | public Object[] toArray()(Code) | | Returns an array containing all of the elements in this deque, in
proper sequence (from first to last element).
The returned array will be "safe" in that no references to it are
maintained by this deque. (In other words, this method must allocate
a new array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based
APIs.
an array containing all of the elements in this deque |
| toArray | | public T[] toArray(T[] a)(Code) | | 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. If the deque fits in the specified array, it
is returned therein. Otherwise, a new array is allocated with the
runtime type of the specified array and the size of this deque.
If this deque fits in the specified array with room to spare
(i.e., the array has more elements than this deque), the element in
the array immediately following the end of the deque is set to
null.
Like the
LinkedBlockingDeque.toArray() method, this method acts as bridge between
array-based and collection-based APIs. Further, this method allows
precise control over the runtime type of the output array, and may,
under certain circumstances, be used to save allocation costs.
Suppose x is a deque known to contain only strings.
The following code can be used to dump the deque into a newly
allocated array of String:
String[] y = x.toArray(new String[0]);
Note that toArray(new Object[0]) is identical in function to
toArray().
Parameters:
a - the array into which the elements of the deque are tobe stored, if it is big enough; otherwise, a new array of thesame runtime type is allocated for this purpose an array containing all of the elements in this deque
throws:
ArrayStoreException - if the runtime type of the specified arrayis not a supertype of the runtime type of every element inthis deque
throws:
NullPointerException - if the specified array is null |
|
|
|