极客教程ConcurrentLinkedDeque在Java中的示例
Java中的ConcurrentLinkedDeque类是Java集合框架的一部分，实现了 Collection接口 和 AbstractCollection类 。它属于 java.util.concurrent 包。它通过LinkedList同时实现Deque的功能。
ConcurrentLinkedDeque的特点
- 迭代器和分割器是弱一致性的。
- 并发插入、删除和访问操作可安全地在多个线程中执行。
- 它不允许空元素。
- size()方法不是在常量时间内实现的。由于这些deque的异步性质，确定当前元素的数量需要遍历这些元素。
Java中的ConcurrentLinkedDeque类是Deque接口的线程安全实现，它使用链接列表来存储元素。ConcurrentLinkedDeque类提供了一种可扩展和高性能的替代方案，尤其是在多个线程同时访问deque的情况下。ConcurrentLinkedDeque类提供了从deque的两端插入和删除元素以及从deque的头部和尾部检索元素的方法，这使它成为在需要执行许多添加和删除操作的情况下的一个好选择。
下面是您在Java中使用ConcurrentLinkedDeque的示例：
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.Deque;
public class Example {
public static void main(String[] args) {
Deque<Integer> deque = new ConcurrentLinkedDeque<>();
deque.addFirst(1);
deque.addLast(2);
int first = deque.pollFirst();
int last = deque.pollLast();
System.out.println("First: " + first + ", Last: " + last);
}
}
输出
First: 1, Last: 2
使用ConcurrentLinkedDeque的优点是：
- 线程安全：ConcurrentLinkedDeque类是线程安全的，这意味着多个线程可以同时访问它而不会遇到数据损坏。
- 高效：ConcurrentLinkedDeque类提供了从deque的两端插入和删除元素的常量时间性能，这使它成为在需要执行许多添加和删除操作的情况下的一个好选择。
- 可扩展性：ConcurrentLinkedDeque类使用链接列表来存储其元素，这使它具有可扩展性，适用于高性能和并发应用。
- 高并发性：ConcurrentLinkedDeque类使用无锁算法，这意味着多个线程可以同时访问deque，而不需要锁定，使它适合高并发应用。
使用ConcurrentLinkedDeque的缺点是：
- 更多的内存开销：ConcurrentLinkedDeque类使用链接列表来存储其元素，这意味着它需要比基于数组的实现（例如ArrayDeque类）更多的内存开销。
- 有限的容量：ConcurrentLinkedDeque类没有限制容量，但它仍然需要存储其元素的内存，这意味着当旧的ConcurrentLinkedDeque消耗太多内存时，您可能需要创建一个新的ConcurrentLinkedDeque。
声明：
public abstract class ConcurrentLinkedDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Serializable
在这里， E 是此集合维护的元素的类型。
它实现了Serializable、Iterable<E>、Collection<E>、Deque<E>、Queue<E>接口。
ConcurrentLinkedDeque的构造函数:
1. ConcurrentLinkedDeque() ：构造一个空deque。
ConcurrentLinkedDeque<E> cld = new ConcurrentLinkedDeque<E>();
**2. ConcurrentLinkedDeque(Collection
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)
{
// 使用ConcurrentLinkedDeque（）
// 构造函数创建ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// 使用addFirst()方法将元素添加到前面
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// 显示现有ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// 使用ConcurrentLinkedDeque（Collection c）
// 构造函数创建ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer>
cld1 = new ConcurrentLinkedDeque<Integer>(cld);
// 显示现有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)
{
// 使用ConcurrentLinkedDeque（）构造函数创建一个ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// 使用addFirst()方法将元素添加到前面
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// 显示现有ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// 显示最后一个元素
// 使用getLast()方法
System.out.println("最后一个元素是: "
+ cld.getLast());
// 显示第一个元素
// 使用peekFirst()方法
System.out.println("第一个元素是: "
+ cld.peekFirst());
// 移除最后一个元素
// 使用removeLast()方法
cld.removeLast();
// 显示现有ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
输出
ConcurrentLinkedDeque: [475, 1009, 70, 12]
The Last element is: 12
First Element is: 475
ConcurrentLinkedDeque: [475, 1009, 70]
ConcurrentLinkedDeque: [475, 1009, 70, 12]
最后一个元素是: 12
第一个元素是: 475
ConcurrentLinkedDeque: [475, 1009, 70]
并发连接双端队列的基本操作
1. 添加元素
为了添加一个元素或多个元素，ConcurrentLinkedDeque提供了像add（E e），addAll（Collection c），addFirst（E e），addLast（E e）等方法。下面的示例解释了这些方法。
“`java
//Java程序演示了向ConcurrentLinkedDeque添加元素
import java.util.concurrent.*;
class AddingElements {
public static void main(String[] args)
{
//使用ConcurrentLinkedDeque创建实例
ConcurrentLinkedDeque<Integer> cld1
= new ConcurrentLinkedDeque<Integer>();
//使用add或addLast方法将元素添加到尾部
cld1.add(12);
cld1.add(110);
//使用addFirst方法将元素添加到头部
cld1.addFirst(55);
//显示现有的ConcurrentLinkedDeque
System.out.println("LinkedDeque cld中的初始元素: "
+ cld1);
//使用ConcurrentLinkedDeque创建实例
ConcurrentLinkedDeque<Integer> cld2
= new ConcurrentLinkedDeque<Integer>();
//使用addAll方法将cld1的元素添加到cld2中
cld2.addAll(cld1);
//显示修改后的ConcurrentLinkedDeque
System.out.println("LinkedDeque cld2中的初始元素: "
+ cld2);
}
}
“`
**输出**
“`java
LinkedDeque cld中的初始元素: [55, 12, 110]
LinkedDeque cld2中的初始元素: [55, 12, 110]
“`
**输出:**
“`java
LinkedDeque cld中的初始元素: [55, 12, 110]
LinkedDeque cld2中的初始元素: [55, 12, 110]
“`
**2\. 删除元素**
要删除一个元素，ConcurrentLinkedDeque提供了像remove（），remove（Object 0），removeFirst（），removeLast（）等方法。这些方法在下面的示例中解释。
“`java
//Java程序演示了从ConcurrentLinkedDeque中删除元素
import java.util.concurrent.*;
class RemovingElements {
public static void main(String[] args)
{
//使用ConcurrentLinkedDeque()构造函数创建ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer> cld
= new ConcurrentLinkedDeque<Integer>();
//使用add()方法添加元素
cld.add(40);
cld.add(50);
cld.add(60);
cld.add(70);
cld.add(80);
//显示现有的LinkedDeque
System.out.println(
"现有的ConcurrentLinkedDeque: " + cld);
//remove方法使用remove()方法删除ConcurrentLinkedDeque的第一个元素
System.out.println("删除的元素为: "
+ cld.remove());
//使用remove(Object)删除60
System.out.println("删除60: " + cld.remove(60));
//显示现有的ConcurrentLinkedDeque
System.out.println(
"修改后的ConcurrentLinkedDeque: " + cld);
//删除第一个元素
cld.removeFirst();
//删除最后一个元素
cld.removeLast();
//显示现有的ConcurrentLinkedDeque
System.out.println(
"修改后的ConcurrentLinkedDeque: " + cld);
}
}
“`
输出 现有的ConcurrentLinkedDeque: [40, 50, 60, 70, 80] 删除的元素为: 40 删除60: true 修改后的ConcurrentLinkedDeque: [50, 70, 80] 修改后的ConcurrentLinkedDeque: [70]
“`java
现有的ConcurrentLinkedDeque：[40, 50, 60, 70, 80]
已删除的元素：40
已删除的60：true
修改后的ConcurrentLinkedDeque：[50, 70, 80]
修改后的ConcurrentLinkedDeque：[70]
“`
**3.迭代元素**
我们可以使用iterator()或descendingIterator()方法迭代ConcurrentLinkedDeque。以下代码解释了这两种方法。
“`java
//用Java代码示例迭代
//元素的ConcurrentLinkedDeque
import java.util.concurrent.*;
import java.util.*;
public class IteratingConcurrentLinkedDeque {
public static void main(String args[])
{
//创建一个空的ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> deque
= new ConcurrentLinkedDeque<String>();
//使用add()方法添加元素进入ConcurrentLinkedDeque
deque.add("Welcome");
deque.add("To");
deque.add("Geeks");
deque.add("4");
deque.add("Geeks");
//展示ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ deque);
//创建一个iterator
Iterator fitr = deque.iterator();
//迭代ConcurrentLinkedDeque后显示值。
System.out.println("The iterator values are: ");
while (fitr.hasNext()) {
System.out.println(fitr.next());
}
//创建一个desc_iterator
Iterator ditr = deque.descendingIterator();
//展示翻转顺序迭代ConcurrentLinkedDeque后的值。
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程序演示访问
//ConcurrentLinkedDeque的元素
import java.util.concurrent.*;
import java.util.*;
class Accessing {
public static void main(String[] args)
{
//创建一个空的ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> cld
= new ConcurrentLinkedDeque<String>();
//将元素添加到ConcurrentLinkedDeque中
cld.add("Welcome");
cld.add("To");
cld.add("Geeks");
cld.add("4");
cld.add("Geeks");
//展示ConcurrentLinkedDeque
System.out.println("Elements in the ConcurrentLinkedDeque: " + cld);
//展示第一个元素
System.out.println("The first element is: "
+ cld.getFirst());
//展示最后一个元素
System.out.println("The Last element is: "
+ cld.getLast());
//展示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
“`
**输出:**
“`java
ConcurrentLinkedDeque中的元素：[欢迎, To, Geeks, 4, Geeks]
第一个元素是：欢迎
最后一个元素是：Geeks
ConcurrentLinkedDeque的头是：欢迎
“`
### ConcurrentLinkedDeque的方法
这里， **E** 是元素的类型。
方法 | 描述
—|—
add(E e) | 将指定的元素插入队列尾部。
addAll(Collection c) | 将指定集合中的所有元素按照迭代器返回的顺序添加到队列末尾。
addFirst(E e) | 将指定的元素插入队列头部。
addLast(E e) | 将指定的元素插入队列尾部。
clear() | 从队列中移除所有元素。
contains(Object o) | 如果队列包含指定的元素，则返回true。
descendingIterator() | 返回一个按照逆序迭代的迭代器。
element() | 检索但不移除该队列的头（即该队列的第一个元素）。
forEach(Consumer action) | 对Iterable的每个元素执行给定的操作，直到所有元素都已经处理或操作引发异常为止。
getFirst() | 检索但不移除队列的第一个元素。
getLast() | 检索但不移除队列的最后一个元素。
isEmpty() | 如果该集合不包含任何元素，则返回true。
iterator() | 返回一个按照正序迭代的迭代器。
offer(E e) | 将指定的元素插入队列尾部。
offerFirst(E e) | 将指定的元素插入队列头部。
offerLast(E e) | 将指定的元素插入队列尾部。
pop() | 弹出存储在该队列中的栈。
push(E e) | 如果可以在不违反容量限制的情况下立即将其推送到该队列的头部，则将元素推送到该队列所表示的栈上，如果当前没有可用空间，则抛出IllegalStateException。
remove() | 检索并移除该队列的头（即该队列的第一个元素）。
remove(Object o) | 从该队列中移除第一个出现的指定元素。
removeAll(Collection c) | 移除该集合中也包含在指定集合中的所有元素（可选操作）。
removeFirst() | 检索并移除该队列的第一个元素。
removeFirstOccurrence(Object o) | 移除该队列中第一次出现的指定元素。
removeIf(Predicate filter) | 移除满足给定谓词的该集合的所有元素。
removeLast() | 检索并移除该队列的最后一个元素。
removeLastOccurrence(Object o) | 移除该队列中最后一次出现的指定元素。
size() | 返回该队列中的元素数。
spliterator() | 创建一个并行迭代器并在此队列的元素中拆分。
toArray() | 以正确的顺序返回一个包含该队列所有元素的数组。
toArray(T[] a) | 以正确的顺序将该队列中的所有元素放入指定的数组中。
removeLastOccurrence(Object o) | 从此双端队列中移除最后一个匹配给定元素的元素。
retainAll(Collection c) | 仅保留此集合中包含在指定集合中的元素（可选操作）。
size() | 返回此双端队列中的元素数。
spliterator() | 返回此双端队列中的元素的 Spliterator。
toArray() | 返回一个包含此双端队列中所有元素的数组，按适当顺序（从第一个到最后一个元素）。
toArray(T[] a) | 返回一个包含此双端队列中所有元素的数组，按适当顺序（从第一个到最后一个元素）；返回数组的运行时类型是指定数组的类型。
java.util.AbstractCollection 类中声明的方法
| 方法 | 描述 |
|---|---|
| containsAll(Collection c) | 如果此集合包含指定集合中的所有元素，则返回 true。 toString() | 返回此集合的字符串表示形式。 ### java.util.Collection 接口中声明的方法 方法 | 描述 |
如果此集合包含指定集合中的所有元素，则返回 true。 |
| equals(Object o) | 将指定的对象与此集合进行比较以测试相等性。 |
| hashCode() | 返回此集合的哈希码值。 |
| parallelStream() | 返回一个可能并行的 Stream 作为此集合的源。 |
| stream() | 返回一个顺序的 Stream 作为此集合的源。 |
| toArray(IntFunction<T[]> generator) | 使用提供的生成器函数分配返回的数组，返回包含此集合中所有元素的数组。 |
java.util.Deque 接口中声明的方法
| 方法 | 描述 |
|---|---|
| peek() | 检索但不删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null。 |
| peekFirst() | 检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。 |
| peekLast() | 检索但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。 |
| poll() | 检索并删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null。 |
| pollFirst() | 检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回 null。 |
| pollLast() | 检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。 |