org.jsr166

## Class ConcurrentLinkedDeque8<E>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - org.jsr166.ConcurrentLinkedDeque8<E>

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

All Implemented Interfaces:
  Serializable, Iterable<E>, Collection<E>, Deque<E>, Queue<E>

    public class ConcurrentLinkedDeque8<E>
    extends AbstractCollection<E>
    implements Deque<E>, Serializable

An unbounded concurrent deque based on linked nodes. Concurrent insertion, removal, and access operations execute safely across multiple threads. A `ConcurrentLinkedDeque` is an appropriate choice when many threads will share access to a common collection. Like most other concurrent collection implementations, this class does not permit the use of `null` elements.

Iterators are weakly consistent, returning elements reflecting the state of the deque at some point at or since the creation of the iterator. They do not throw `ConcurrentModificationException`, and may proceed concurrently with other operations.

Beware that, unlike in most collections, the `size` method is NOT a constant-time operation. Because of the asynchronous nature of these deques, determining the current number of elements requires a traversal of the elements, and so may report inaccurate results if this collection is modified during traversal. Additionally, the bulk operations `addAll`, `removeAll`, `retainAll`, `containsAll`, `equals`, and `toArray` are not guaranteed to be performed atomically. For example, an iterator operating concurrently with an `addAll` operation might view only some of the added elements.

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

Memory consistency effects: As with other concurrent collections, actions in a thread prior to placing an object into a `ConcurrentLinkedDeque` happen-before actions subsequent to the access or removal of that element from the `ConcurrentLinkedDeque` in another thread.

This class is a member of the Java Collections Framework.

Since:
  1.7
See Also:
  Serialized Form

### Nested Class Summary

Nested Classes
`static class` `ConcurrentLinkedDeque8.Node<E>`

### Constructor Summary

Constructors
Constructor and Description
`ConcurrentLinkedDeque8()` Constructs an empty deque.
`ConcurrentLinkedDeque8(Collection<? extends E> c)` Constructs a deque initially containing the elements of the given collection, added in traversal order of the collection's iterator.

### Method Summary

All Methods Instance Methods Concrete Methods
`boolean` `add(E e)` Inserts the specified element at the tail of this deque.
`boolean` `addAll(Collection<? extends E> c)` Appends all of the elements in the specified collection to the end of this deque, in the order that they are returned by the specified collection's iterator.
`void` `addFirst(E e)` Inserts the specified element at the front of this deque.
`void` `addLast(E e)` Inserts the specified element at the end of this deque.
`ConcurrentLinkedDeque8.Node<E>` `addLastx(E e)` Same as `addLast(Object)`, but returns new node.
`ConcurrentLinkedDeque8.Node<E>` `addx(E e)` Same as `add(Object)`, but returns new node.
`void` `clear()` Removes all of the elements from this deque.
`boolean` `contains(Object o)` Returns `true` if this deque contains at least one element `e` such that `o.equals(e)`.
`Iterator<E>` `descendingIterator()` Returns an iterator over the elements in this deque in reverse sequential order.
`E` `element()`
`E` `getFirst()`
`E` `getLast()`
`boolean` `isEmpty()` Returns `true` if this collection contains no elements.
`boolean` `isEmptyx()` Returns `true` if this collection contains no elements.
`Iterator<E>` `iterator()` Returns an iterator over the elements in this deque in proper sequence.
`boolean` `offer(E e)` Inserts the specified element at the tail of this deque.
`boolean` `offerFirst(E e)` Inserts the specified element at the front of this deque.
`ConcurrentLinkedDeque8.Node<E>` `offerFirstx(E e)` Same as `offerFirst(Object)`, but returns new `ConcurrentLinkedDeque8.Node`.
`boolean` `offerLast(E e)` Inserts the specified element at the end of this deque.
`ConcurrentLinkedDeque8.Node<E>` `offerLastx(E e)` Same as `offerLast(Object)`, but returns new `ConcurrentLinkedDeque8.Node`.
`E` `peek()`
`E` `peekFirst()`
`ConcurrentLinkedDeque8.Node<E>` `peekFirstx()` Retrieves, but does not remove, the first node of this deque, or returns `null` if this deque is empty.
`E` `peekLast()`
`ConcurrentLinkedDeque8.Node<E>` `peekx()` Retrieves, but does not remove, the header node of the queue represented by this deque (in other words, the first node of this deque), or returns `null` if this deque is empty.
`E` `poll()`
`E` `pollFirst()`
`E` `pollLast()`
`E` `pop()`
`void` `push(E e)`
`E` `remove()`
`boolean` `remove(Object o)` Removes the first element `e` such that `o.equals(e)`, if such an element exists in this deque.
`E` `removeFirst()`
`boolean` `removeFirstOccurrence(Object o)` Removes the first element `e` such that `o.equals(e)`, if such an element exists in this deque.
`E` `removeLast()`
`boolean` `removeLastOccurrence(Object o)` Removes the last element `e` such that `o.equals(e)`, if such an element exists in this deque.
`int` `size()` Returns the number of elements in this deque.
`int` `sizex()`
`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 (from first to last element); the runtime type of the returned array is that of the specified array.
`boolean` `unlinkx(ConcurrentLinkedDeque8.Node<E> x)` Unlinks non-null node x, that has not yet been unlinked.

### Methods inherited from class java.util.AbstractCollection

`containsAll, removeAll, retainAll, toString`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface java.util.Collection

`containsAll, equals, hashCode, parallelStream, removeAll, removeIf, retainAll, spliterator, stream`

### Methods inherited from interface java.lang.Iterable

`forEach`

### Constructor Detail

#### ConcurrentLinkedDeque8

    public ConcurrentLinkedDeque8()

Constructs an empty deque.

#### ConcurrentLinkedDeque8

    public ConcurrentLinkedDeque8(Collection<? extends E> c)

Constructs a deque 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

### Method Detail

#### unlinkx

    public boolean unlinkx(ConcurrentLinkedDeque8.Node<E> x)

Unlinks non-null node x, that has not yet been unlinked.

Parameters:
  `x` - Node.
Returns:
  `True` if node was unlinked by this call.

#### addFirst

    public void addFirst(E e)

Inserts the specified element at the front of this deque. As the deque is unbounded, this method will never throw `IllegalStateException`.

Specified by:
  `addFirst` in interface `Deque<E>`
Throws:
  `NullPointerException` - if the specified element is null

#### addLast

    public void addLast(E e)

Inserts the specified element at the end of this deque. As the deque is unbounded, this method will never throw `IllegalStateException`.

This method is equivalent to `add(E)`.

Specified by:
  `addLast` in interface `Deque<E>`
Throws:
  `NullPointerException` - if the specified element is null

#### addLastx

    public ConcurrentLinkedDeque8.Node<E> addLastx(E e)

Same as `addLast(Object)`, but returns new node.

Parameters:
  `e` - Element to add.
Returns:
  New node.

#### offerFirst

    public boolean offerFirst(E e)

Inserts the specified element at the front of this deque. As the deque is unbounded, this method will never return `false`.

Specified by:
  `offerFirst` in interface `Deque<E>`
Returns:
  `true` (as specified by `Deque.offerFirst(E)`)
Throws:
  `NullPointerException` - if the specified element is null

#### offerFirstx

    public ConcurrentLinkedDeque8.Node<E> offerFirstx(E e)

Same as `offerFirst(Object)`, but returns new `ConcurrentLinkedDeque8.Node`.

Parameters:
  `e` - Element to add.
Returns:
  New node.

#### offerLast

    public boolean offerLast(E e)

Inserts the specified element at the end of this deque. As the deque is unbounded, this method will never return `false`.

This method is equivalent to `add(E)`.

Specified by:
  `offerLast` in interface `Deque<E>`
Returns:
  `true` (as specified by `Deque.offerLast(E)`)
Throws:
  `NullPointerException` - if the specified element is null

#### offerLastx

    public ConcurrentLinkedDeque8.Node<E> offerLastx(E e)

Same as `offerLast(Object)`, but returns new `ConcurrentLinkedDeque8.Node`.

Parameters:
  `e` - Element to add.
Returns:
  New node.

#### peekFirst

    public E peekFirst()

Specified by:
  `peekFirst` in interface `Deque<E>`

#### peekFirstx

    public ConcurrentLinkedDeque8.Node<E> peekFirstx()

Retrieves, but does not remove, the first node of this deque, or returns `null` if this deque is empty.

Returns:
  The header node of this deque, or `null` if this deque is empty

#### peekLast

    public E peekLast()

Specified by:
  `peekLast` in interface `Deque<E>`

#### getFirst

    public E getFirst()

Specified by:
  `getFirst` in interface `Deque<E>`

#### getLast

    public E getLast()

Specified by:
  `getLast` in interface `Deque<E>`

#### pollFirst

    public E pollFirst()

Specified by:
  `pollFirst` in interface `Deque<E>`

#### pollLast

    public E pollLast()

Specified by:
  `pollLast` in interface `Deque<E>`

#### removeFirst

    public E removeFirst()

Specified by:
  `removeFirst` in interface `Deque<E>`

#### removeLast

    public E removeLast()

Specified by:
  `removeLast` in interface `Deque<E>`

#### offer

    public boolean offer(E e)

Inserts the specified element at the tail of this deque. As the deque is unbounded, this method will never return `false`.

Specified by:
  `offer` in interface `Deque<E>`
Specified by:
  `offer` in interface `Queue<E>`
Returns:
  `true` (as specified by `Queue.offer(E)`)
Throws:
  `NullPointerException` - if the specified element is null

#### add

    public boolean add(E e)

Inserts the specified element at the tail of this deque. As the deque is unbounded, this method will never throw `IllegalStateException` or return `false`.

Specified by:
  `add` in interface `Collection<E>`
Specified by:
  `add` in interface `Deque<E>`
Specified by:
  `add` in interface `Queue<E>`
Overrides:
  `add` in class `AbstractCollection<E>`
Returns:
  `true` (as specified by `Collection.add(E)`)
Throws:
  `NullPointerException` - if the specified element is null

#### addx

    public ConcurrentLinkedDeque8.Node<E> addx(E e)

Same as `add(Object)`, but returns new node.

Parameters:
  `e` - Element to add.
Returns:
  New node.

#### poll

    public E poll()

Specified by:
  `poll` in interface `Deque<E>`
Specified by:
  `poll` in interface `Queue<E>`

#### remove

    public E remove()

Specified by:
  `remove` in interface `Deque<E>`
Specified by:
  `remove` in interface `Queue<E>`

#### peek

    public E peek()

Specified by:
  `peek` in interface `Deque<E>`
Specified by:
  `peek` in interface `Queue<E>`

#### element

    public E element()

Specified by:
  `element` in interface `Deque<E>`
Specified by:
  `element` in interface `Queue<E>`

#### push

    public void push(E e)

Specified by:
  `push` in interface `Deque<E>`

#### pop

    public E pop()

Specified by:
  `pop` in interface `Deque<E>`

#### peekx

    public ConcurrentLinkedDeque8.Node<E> peekx()

Retrieves, but does not remove, the header node of the queue represented by this deque (in other words, the first node of this deque), or returns `null` if this deque is empty.

This method is equivalent to `peekFirst()`.

Returns:
  The header node of the queue represented by this deque, or `null` if this deque is empty

#### removeFirstOccurrence

    public boolean removeFirstOccurrence(Object o)

Removes the first element `e` such that `o.equals(e)`, if such an element exists in this deque. If the deque does not contain the element, it is unchanged.

Specified by:
  `removeFirstOccurrence` in interface `Deque<E>`
Parameters:
  `o` - element to be removed from this deque, if present
Returns:
  `true` if the deque contained the specified element
Throws:
  `NullPointerException` - if the specified element is null

#### removeLastOccurrence

    public boolean removeLastOccurrence(Object o)

Removes the last element `e` such that `o.equals(e)`, if such an element exists in this deque. If the deque does not contain the element, it is unchanged.

Specified by:
  `removeLastOccurrence` in interface `Deque<E>`
Parameters:
  `o` - element to be removed from this deque, if present
Returns:
  `true` if the deque contained the specified element
Throws:
  `NullPointerException` - if the specified element is null

#### contains

    public boolean contains(Object o)

Returns `true` if this deque contains at least one element `e` such that `o.equals(e)`.

Specified by:
  `contains` in interface `Collection<E>`
Specified by:
  `contains` in interface `Deque<E>`
Overrides:
  `contains` in class `AbstractCollection<E>`
Parameters:
  `o` - element whose presence in this deque is to be tested
Returns:
  `true` if this deque contains the specified element

#### isEmpty

    public boolean isEmpty()

Returns `true` if this collection contains no elements.

Specified by:
  `isEmpty` in interface `Collection<E>`
Overrides:
  `isEmpty` in class `AbstractCollection<E>`
Returns:
  `true` if this collection contains no elements

#### isEmptyx

    public boolean isEmptyx()

Returns `true` if this collection contains no elements.

The difference from `isEmpty()` method is that this method relies on `sizex()` method.

Returns:
  `True` if this collection contains no elements

#### size

    public int size()

Returns the number of elements in this deque. If this deque contains more than `Integer.MAX_VALUE` elements, it returns `Integer.MAX_VALUE`.

Beware that, unlike in most collections, this method is NOT a constant-time operation. Because of the asynchronous nature of these deques, determining the current number of elements requires traversing them all to count them. Additionally, it is possible for the size to change during execution of this method, in which case the returned result will be inaccurate. Thus, this method is typically not very useful in concurrent applications.

Specified by:
  `size` in interface `Collection<E>`
Specified by:
  `size` in interface `Deque<E>`
Specified by:
  `size` in class `AbstractCollection<E>`
Returns:
  the number of elements in this deque

#### sizex

    public int sizex()

Returns:
  Size based on performed operations.

#### remove

    public boolean remove(Object o)

Removes the first element `e` such that `o.equals(e)`, if such an element exists in this deque. If the deque does not contain the element, it is unchanged.

Specified by:
  `remove` in interface `Collection<E>`
Specified by:
  `remove` in interface `Deque<E>`
Overrides:
  `remove` in class `AbstractCollection<E>`
Parameters:
  `o` - element to be removed from this deque, if present
Returns:
  `true` if the deque contained the specified element
Throws:
  `NullPointerException` - if the specified element is null

#### addAll

    public boolean addAll(Collection<? extends E> c)

Appends all of the elements in the specified collection to the end of this deque, in the order that they are returned by the specified collection's iterator. Attempts to `addAll` of a deque to itself result in `IllegalArgumentException`.

Specified by:
  `addAll` in interface `Collection<E>`
Overrides:
  `addAll` in class `AbstractCollection<E>`
Parameters:
  `c` - the elements to be inserted into this deque
Returns:
  `true` if this deque changed as a result of the call
Throws:
  `NullPointerException` - if the specified collection or any of its elements are null
  `IllegalArgumentException` - if the collection is this deque

#### clear

    public void clear()

Removes all of the elements from this deque.

Specified by:
  `clear` in interface `Collection<E>`
Overrides:
  `clear` in class `AbstractCollection<E>`

#### toArray

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

Specified by:
  `toArray` in interface `Collection<E>`
Overrides:
  `toArray` in class `AbstractCollection<E>`
Returns:
  an array containing all of the elements in this deque

#### toArray

    public <T> T[] toArray(T[] a)

Returns an array containing all of the elements in this deque, in proper sequence (from first to last element); 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 `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()`.

Specified by:
  `toArray` in interface `Collection<E>`
Overrides:
  `toArray` in class `AbstractCollection<E>`
Parameters:
  `a` - the array into which the elements of the deque are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose
Returns:
  an array containing all of the elements in this deque
Throws:
  `ArrayStoreException` - if the runtime type of the specified array is not a supertype of the runtime type of every element in this deque
  `NullPointerException` - if the specified array is null

#### iterator

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

#### descendingIterator

    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 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:
  `descendingIterator` in interface `Deque<E>`
Returns:
  an iterator over the elements in this deque in reverse order

${current.year} Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Database and Caching Platform | : ver. 2.8.1
Release Date | : May 21 2020