极客教程Java ConcurrentLinkedDeque 与实例
Java中的 ConcurrentLinkedDeque 类是Java集合框架的一部分，实现了 Collection接口 和 AbstractCollection类。 它属于 java.util.concurrent 包。它被用来在LinkedList的帮助下并发地实现Deque。
ConcurrentLinkedDeque的特点
- 迭代器和拆分器是弱一致性的。
- 并发的插入、移除和访问操作在多个线程中安全执行。
- 它不允许空元素。
- size()方法不是以恒定时间实现的。由于这些脱扣器的异步性，确定当前元素的数量需要对元素进行遍历。
类的层次结构
声明：
public abstract class ConcurrentLinkedDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Serializable
Here, **E** is the type of elements maintained by this collection.
它实现了Serializable, Iterable<E>, Collection<E>, Deque<E> , Queue<E>接口。
ConcurrentLinkedDeque的构造函数：
1.ConcurrentLinkedDeque() : 这个构造函数用来构造一个空的deque。
ConcurrentLinkedDeque<E> cld = new ConcurrentLinkedDeque<E>()
2.ConcurrentLinkedDeque(Collection <E> c): 该构造函数用于构造一个以Collection元素为参数的deque。
ConcurrentLinkedDeque<E> cld = new ConcurrentLinkedDeque<E>（Collection<E> c）
下面是说明Java中ConcurrentLinkedDeque的示例程序：
// Java Program to demonstrate ConcurrentLinkedDeque
import java.util.concurrent.*;
class ConcurrentLinkedDequeDemo {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque()
// constructor
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// add element to the front
// using addFirst() method
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque(Collection c)
// constructor
ConcurrentLinkedDeque<Integer>
cld1 = new ConcurrentLinkedDeque<Integer>(cld);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque1: "
+ cld1);
}
}
输出
ConcurrentLinkedDeque: [475, 1009, 70, 12]
ConcurrentLinkedDeque1: [475, 1009, 70, 12]
例如：
// Java code to illustrate
// methods of ConcurrentLinkedDeque
import java.util.concurrent.*;
class ConcurrentLinkedDequeDemo {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque() constructor
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// add element to the front
// using addFirst() method
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// Displaying the Last element
// using getLast() method
System.out.println("The Last element is: "
+ cld.getLast());
// Displaying the first element
// using peekFirst() method
System.out.println("First Element is: "
+ cld.peekFirst());
// Remove the Last element
// using removeLast() method
cld.removeLast();
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
}
}
输出
ConcurrentLinkedDeque: [475, 1009, 70, 12]
The Last element is: 12
First Element is: 475
ConcurrentLinkedDeque: [475, 1009, 70]
并行连接的Deque的基本操作
1.添加元素
为了添加一个元素或元素集合，ConcurrentLinkedDeque提供了add(E e)、addAll(Collection c)、addFirst(E e)、addLast(E e)等方法。下面的例子解释了这些方法。
“`java
// Java Program Demonstrate adding
// elements to the ConcurrentLinkedDeque
import java.util.concurrent.*;
class AddingElements {
public static void main(String[] args)
{
// create instance using ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer> cld1
= new ConcurrentLinkedDeque<Integer>();
// Add element to the tail using
// add or addLast methods
cld1.add(12);
cld1.add(110);
// Add element to the head
// using addFirst method
cld1.addFirst(55);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("Initial Elements in "
+ "the LinkedDeque cld : "
+ cld1);
// create instance using ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer> cld2
= new ConcurrentLinkedDeque<Integer>();
// Add elements of cld1 to the
// cld2 using addAll method
cld2.addAll(cld1);
// Displaying the modified ConcurrentLinkedDeque
System.out.println("Initial Elements in "
+ "the LinkedDeque cld2: "
+ cld2);
}
}
“`
**输出**
“`java
Initial Elements in the LinkedDeque cld : [55, 12, 110]
Initial Elements in the LinkedDeque cld2: [55, 12, 110]
“`
**2.移除元素**
为了移除一个元素，ConcurrentLinkedDeque提供了一些方法，比如remove(), remove(Object o), removeFirst(), removeLast()等。这些方法在下面的例子中得到了解释。
“`java
// Java Program to demonstrate removing
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
class RemovingElements {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque() constructor
ConcurrentLinkedDeque<Integer> cld
= new ConcurrentLinkedDeque<Integer>();
// Add elements using add() method
cld.add(40);
cld.add(50);
cld.add(60);
cld.add(70);
cld.add(80);
// Displaying the existing LinkedDeque
System.out.println(
"Existing ConcurrentLinkedDeque: " + cld);
// remove method removes the first
// element of ConcurrentLinkedDeque
// using remove() method
System.out.println("Element removed: "
+ cld.remove());
// Remove 60 using remove(Object)
System.out.println("60 removed: " + cld.remove(60));
// Displaying the existing ConcurrentLinkedDeque
System.out.println(
"Modified ConcurrentLinkedDeque: " + cld);
// Remove the first element
cld.removeFirst();
// Remove the Last element
cld.removeLast();
// Displaying the existing ConcurrentLinkedDeque
System.out.println(
"Modified ConcurrentLinkedDeque: " + cld);
}
}
“`
**输出**
“`java
Existing ConcurrentLinkedDeque: [40, 50, 60, 70, 80]
Element removed: 40
60 removed: true
Modified ConcurrentLinkedDeque: [50, 70, 80]
Modified ConcurrentLinkedDeque: [70]
“`
**3.迭代元素**
我们可以使用iterator()或descendingIterator()方法对ConcurrentLinkedDeque进行迭代。下面的代码解释了这两种方法。
“`java
// Java code to illustrate iterating
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
import java.util.*;
public class IteratingConcurrentLinkedDeque {
public static void main(String args[])
{
// Creating an empty ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> deque
= new ConcurrentLinkedDeque<String>();
// Use add() method to add elements
// into the ConcurrentLinkedDeque
deque.add("Welcome");
deque.add("To");
deque.add("Geeks");
deque.add("4");
deque.add("Geeks");
// Displaying the ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ deque);
// Creating an iterator
Iterator fitr = deque.iterator();
// Displaying the values
// after iterating through the ConcurrentLinkedDeque
System.out.println("The iterator values are: ");
while (fitr.hasNext()) {
System.out.println(fitr.next());
}
// Creating a desc_iterator
Iterator ditr = deque.descendingIterator();
// Displaying the values after iterating
// through the ConcurrentLinkedDeque
// in reverse order
System.out.println("The iterator values are: ");
while (ditr.hasNext()) {
System.out.println(ditr.next());
}
}
}
“`
**输出**
“`java
ConcurrentLinkedDeque: [Welcome, To, Geeks, 4, Geeks]
The iterator values are:
Welcome
To
Geeks
4
Geeks
The iterator values are:
Geeks
4
Geeks
To
Welcome
“`
**4.访问元素**
为了访问ConcurrentLinkedDeque的元素，它提供了像getFirst(), getLast(), element()方法。下面的例子解释了这些方法。
“`java
// Java Program to Demonstrate accessing
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
import java.util.*;
class Accessing {
public static void main(String[] args)
{
// Creating an empty ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> cld
= new ConcurrentLinkedDeque<String>();
// Add elements into the ConcurrentLinkedDeque
cld.add("Welcome");
cld.add("To");
cld.add("Geeks");
cld.add("4");
cld.add("Geeks");
// Displaying the ConcurrentLinkedDeque
System.out.println("Elements in the ConcurrentLinkedDeque: " + cld);
// Displaying the first element
System.out.println("The first element is: "
+ cld.getFirst());
// Displaying the Last element
System.out.println("The Last element is: "
+ cld.getLast());
// Displaying the head of ConcurrentLinkedDeque
System.out.println("The Head of ConcurrentLinkedDeque is: "
+ cld.element());
}
}
“`
**输出：**
“`java
Elements in the ConcurrentLinkedDeque: [Welcome, To, Geeks, 4, Geeks]
The first element is: Welcome
The Last element is: Geeks
The Head of ConcurrentLinkedDeque is: Welcome
“`
### ConcurrentLinkedDeque的方法
这里， **E** 是元素的类型。
方法 | 描述
—|—
add(E e) | 在这个deque的尾部插入指定的元素。
addAll(Collection c) | 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到这个deque的末尾。
addFirst(E e) | 在这个deque的前面插入指定的元素。
addLast(E e) | 在这个deque的最后插入指定的元素。
clear() | 移除这个deque中的所有元素。
contains(Object o) | 如果这个deque包含指定的元素，返回true。
descendingIterator() | 以相反的顺序返回这个deque中的元素的一个迭代器。
element() | 检索但不删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素）。
forEach(Consumer action) | 对Iterable的每个元素执行给定的动作，直到所有的元素都被处理完，或者该动作抛出一个异常。
getFirst() | 检索，但不删除，这个deque的第一个元素。
getLast() | 读取但不删除这个deque的最后一个元素。
isEmpty() | 如果这个集合不包含任何元素，返回true。
iterator() | 以适当的顺序返回这个deque中的元素的迭代器。
offer(E e) | 在这个deque的尾部插入指定的元素。
offerFirst(E e) | 在这个deque的前面插入指定的元素。
offerLast(E e) | 在这个deque的末尾插入指定的元素。
pop() | 从这个deque所代表的堆栈中弹出一个元素。
push(E e) | 如果在不违反容量限制的情况下，可以立即将一个元素推到这个deque所代表的堆栈上（换句话说，推到这个deque的头部），如果当前没有可用空间，则抛出IllegalStateException。
remove() | 检索并删除这个deque所代表的队列的头部（换句话说，就是这个deque的第一个元素）。
remove(Object o) | 移除这个deque中第一个出现的指定元素。
removeAll(Collection c) | 移除此集合中也包含在指定集合中的所有元素（可选操作）。
removeFirst() | 检索并删除此deque中的第一个元素。
removeFirstOccurrence(Object o) | 移除此deque中指定元素的第一次出现。
removeIf(Predicate filter) | 删除这个集合中满足给定谓词的所有元素。
removeLast() | 检索并删除此deque中的最后一个元素。
removeLastOccurrence(Object o) | 移除这个deque中最后出现的指定元素。
retainAll(Collection c) | 只保留这个集合中包含在指定集合中的元素（可选操作）。
size() | 返回这个deque中元素的数量。
spliterator() | 返回这个deque中的元素的一个Spliterator。
toArray() | 返回一个包含所有deque元素的数组，按照正确的顺序（从第一个元素到最后一个元素）。
toArray(T[] a) | 返回一个数组，包含这个deque中的所有元素，按照适当的顺序（从第一个元素到最后一个元素）；返回的数组的运行时类型是指定数组的类型。
java.util.AbstractCollection类中声明的方法
| 方法 | 描述 |
|---|---|
| containsAll(Collection c) | 如果这个集合包含了指定集合中的所有元素，返回true。 toString() | 返回这个集合的一个字符串表示。 ### java.util.Collection接口中声明的方法 方法 | 描述 |
如果这个集合包含了指定集合中的所有元素，返回true。 |
| equals(Object o) | 将指定的对象与这个集合进行比较，看是否相等。 |
| 哈希代码() | 返回这个集合的哈希代码值。 |
| parallelStream() | 返回一个以该集合为源的可能的并行流。 |
| stream() | 返回一个以这个集合为源的顺序流。 |
| toArray(IntFunction<T[]> generator) | 返回一个包含此集合中所有元素的数组，使用提供的生成器函数来分配返回的数组。 |
java.util.Deque接口中声明的方法
| 方法 | 描述 |
|---|---|
| peek() | 检索但不删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素），如果这个deque为空，则返回null。 |
| peekFirst() | 检索但不删除这个deque的第一个元素，如果这个deque是空的，则返回null。 |
| peekLast() | 检索但不删除这个deque的最后一个元素，如果这个deque是空的，则返回null。 |
| poll() | 检索并删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素），如果这个deque是空的，则返回null。 |
| pollFirst() | 检索并删除这个deque的第一个元素，如果这个deque是空的，则返回null。 |
| pollLast() | 检索并删除这个deque中的最后一个元素，如果这个deque是空的，则返回null。 |
参考资料 : https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentLinkedDeque.html