ConcurrentLinkedDeque

ConcurrentLinkedDeque

ConcurrentLinkedDeque()

Constructs an empty deque.

ConcurrentLinkedDeque

ConcurrentLinkedDeque(c: MutableCollection<out E>!)

Constructs a deque initially containing the elements of the given collection, added in traversal order of the collection's iterator.

add

open fun add(element: E): Boolean

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

addAll

open fun addAll(elements: Collection<E>): Boolean

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.

addFirst

open fun addFirst(e: E): Unit

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

addLast

open fun addLast(e: E): Unit

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.

clear

open fun clear(): Unit

Removes all of the elements from this deque.

contains

open fun contains(element: E?): Boolean

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

descendingIterator

open fun descendingIterator(): MutableIterator<E>

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.

element

open fun element(): E

forEach

open fun forEach(action: Consumer<in E>): Unit

getFirst

open fun getFirst(): E

getLast

open fun getLast(): E

isEmpty

open fun isEmpty(): Boolean

Returns true if this collection contains no elements.

iterator

open fun iterator(): MutableIterator<E>

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.

offer

open fun offer(e: E): Boolean

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

offerFirst

open fun offerFirst(e: E): Boolean

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

offerLast

open fun offerLast(e: E): Boolean

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.

peek

open fun peek(): E?

peekFirst

open fun peekFirst(): E?

peekLast

open fun peekLast(): E?

poll

open fun poll(): E?

pollFirst

open fun pollFirst(): E?

pollLast

open fun pollLast(): E?

pop

open fun pop(): E

push

open fun push(e: E): Unit

remove

open fun remove(): E

remove

open fun remove(element: E?): Boolean

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 removeFirstOccurrence(java.lang.Object).

removeAll

open fun removeAll(elements: Collection<E>): Boolean

removeFirst

open fun removeFirst(): E

removeFirstOccurrence

open fun removeFirstOccurrence(o: Any?): Boolean

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

removeIf

open fun removeIf(filter: Predicate<in E>): Boolean

removeLast

open fun removeLast(): E

removeLastOccurrence

open fun removeLastOccurrence(o: Any?): Boolean

Removes the last occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the last 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).

retainAll

open fun retainAll(elements: Collection<E>): Boolean

spliterator

open fun spliterator(): Spliterator<E>

Returns a Spliterator over the elements in this deque.

The returned spliterator is weakly consistent.

The Spliterator reports Spliterator#CONCURRENT, Spliterator#ORDERED, and Spliterator#NONNULL.

toArray

open fun toArray(): Array<Any!>

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.

toArray

open fun <T : Any!> toArray(a: Array<T>): Array<T>

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:

<code>String[] y = x.toArray(new String[0]);</code>

toString

open fun toString(): String

size

open val size: Int

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.