极客教程Java中的BlockingDeque
BlockingDeque 接口是Java集合框架的一部分。它得名是因为它会阻止非法操作，例如插入到一个已满队列中或从空队列中删除，所有这些属性都内置在这个接口的结构中。由于它是一个双端队列(deque)，因此可以从两端执行插入、删除和遍历操作。BlockingDeque是一个接口，所以我们不能声明任何对象。
层次结构
BlockingDeque继承自BlockingQueue接口，而BlockingQueue接口又继承自 队列接口 和 双端队列接口 。
BlockingDeque的层次结构
注意： 集合框架的接口可能有额外的实现类和扩展接口，但以上图片仅显示BlockingDeque及其实现类的层次结构。
语法：
public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E>
这里， E 是集合中元素的类型。
实现BlockingDeque的类
实现BlockingDeque的类为 LinkedBlockingDeque 。这个类是BlockingDeque和链表数据结构的实现。LinkedBlockingDeque可以使用构造函数可选地绑定，但是，如果容量未指定，则默认为 Integer.MAX_VALUE 。在插入时，节点会动态添加，遵守容量限制。要在您的代码中使用BlockingDeque，请使用以下导入语句。
import java.util.concurrent.BlockingDeque;
(或)
import java.util.concurrent.*;
创建对象的语法：
LinkedBlockingDeque<?> objectName = new LinkedBlockingDeque<?>();
(或)
BlockingDeque<?> objectName = new LinkedBlockingDeque<?>();
示例： 在下面的代码中，我们对LinkedBlockingDeque执行一些基本操作，如创建一个对象、添加元素、删除元素，并使用迭代器遍历LinkedBlockingDeque。
//Java程序用于BlockingDeque
import java.util.concurrent.*;
import java.util.*;
public class BlockingDequeExample {
public static void main(String[] args) {
//使用LinkedBlockingDeque命名lbdq实例化对象
BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
//使用add()添加元素
lbdq.add(134);
lbdq.add(245);
lbdq.add(23);
lbdq.add(122);
lbdq.add(90);
//创建一个迭代器用于遍历这个双端队列
Iterator<Integer> lbdqIter = lbdq.iterator();
//将lbdq的元素打印到控制台上
System.out.println("The LinkedBlockingDeque lbdq contains:");
for(int i = 0; i<lbdq.size(); i++)
{
System.out.print(lbdqIter.next() + " ");
}
//移除23并且如果操作是成功的则显示适当的消息
if(lbdq.remove(23))
{
System.out.println("\n\nThe element 23 has been removed");
}
else
{
System.out.println("\n\nNo such element was found");
}
//不使用迭代器打印lbdq的元素
System.out.println("\nThe LinkedBlockingDeque lbdq"+
" after remove operation contains:");
System.out.println(lbdq);
}
}
输出:
The LinkedBlockingDeque lbdq contains:
134 245 23 122 90
The element 23 has been removed
The LinkedBlockingDeque lbdq after remove operation contains:
[134, 245, 122, 90]
基本操作
1. 添加元素
可以使用不同的方式向LinkedBlockedDeque添加元素，这取决于我们试图使用的结构类型。最常见的方法是使用add()方法，在双端队列的末尾添加元素。我们还可以使用addAll()方法（它是Collection接口的一种方法）将整个集合添加到LinkedBlockingDeque中。如果我们希望将该双端队列用作队列，则可以使用add()和put()。
// Java程序添加元素到LinkedBlockingDeque中
import java.util.concurrent.*;
public class AddingElements {
public static void main(String[] args) {
//实例化命名为lbdq1的LinkedBlockingDeque
BlockingDeque<Integer> lbdq1 = new LinkedBlockingDeque<Integer>();
//使用add()添加元素
lbdq1.add(145);
lbdq1.add(89);
lbdq1.add(65);
lbdq1.add(122);
lbdq1.add(11);
//在控制台上打印lbdq1的内容
System.out.println("Contents of lbdq1: " + lbdq1);
//实例化命名为lbdq2的LinkedBlockingDeque
LinkedBlockingDeque<Integer> lbdq2 = new LinkedBlockingDeque<Integer>();
//使用addAll()从lbdq1添加元素
lbdq2.addAll(lbdq1);
//在控制台上打印lbdq2的内容
System.out.println("\nContents of lbdq2: " + lbdq2);
}
}
输出
Contents of lbdq1: [145, 89, 65, 122, 11]
Contents of lbdq2: [145, 89, 65, 122, 11]
2. 访问元素
LinkedBlockingDeque的元素可以使用contains()、element()、peek()和poll()访问。在上面的表格中还有这些方法的变体及其描述。
// 访问LinkedBlockingDeque元素的Java程序
import java.util.concurrent.*;
public class AccessingElements {
public static void main(String[] args) {
// 实例化一个名为lbdq的LinkedBlockingDeque对象
BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
// 使用add()添加元素
lbdq.add(22);
lbdq.add(125);
lbdq.add(723);
lbdq.add(172);
lbdq.add(100);
// 在控制台上打印lbdq的元素
System.out.println("LinkedBlockingDeque lbdq 包含:");
System.out.println(lbdq);
// 检查deque是否包含元素22
if(lbdq.contains(22))
System.out.println("LinkedBlockingDeque lbdq 包含元素22");
else
System.out.println("没有这个元素");
// 使用element()获取deque的头元素
int head = lbdq.element();
System.out.println("lbdq的头元素是: " + head);
// 使用peekLast()获取deque的尾部元素
int tail = lbdq.peekLast();
System.out.println("lbdq的尾部元素是: " + tail);
}
}
输出
LinkedBlockingDeque lbdq 包含:
[22, 125, 723, 172, 100]
LinkedBlockingDeque lbdq 包含元素22
lbdq的头元素是: 22
lbdq的尾部元素是: 100
3. 删除元素
可以使用 remove() 方法从LinkedBlockingDeque中删除元素。还可以使用take()、poll()等其他方法以一种方式删除第一个和最后一个元素。
// 从LinkedBlockingDeque中删除元素的Java程序
import java.util.concurrent.*;
public class RemovingElements {
public static void main(String[] args) {
// 实例化一个名为lbdq的LinkedBlockingDeque对象
BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
// 使用add()添加元素
lbdq.add(75);
lbdq.add(86);
lbdq.add(13);
lbdq.add(44);
lbdq.add(10);
// 在控制台上打印lbdq的元素
System.out.println("LinkedBlockingDeque lbdq 包含:");
System.out.println(lbdq);
// 使用remove()删除元素;
lbdq.remove(86);
lbdq.remove(44);
// 尝试删除不存在于LinkedBlockingDeque中的元素
lbdq.remove(1);
// 在控制台上打印lbdq的元素
System.out.println("\nLinkedBlockingDeque lbdq 包含:");
System.out.println(lbdq);
}
}
输出
LinkedBlockingDeque lbdq 包含:
[75, 86, 13, 44, 10]
LinkedBlockingDeque lbdq 包含:
[75, 13, 10]
4. 遍历元素
为了遍历LinkedBlockingDeque的元素，我们可以创建一个迭代器，并使用Java的集合框架的根接口Iterable的方法来访问元素。Iterable的next()方法返回任何集合的元素。
// 遍历 LinkedBlockingDeque 的 Java 程序
import java.util.Iterator;
import java.util.concurrent.*;
public class IteratingThroughElements {
public static void main(String[] args) {
// 实例化 名为 lbdq 的 LinkedBlockingDeque 对象
BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
// 使用 add() 方法添加元素
lbdq.add(166);
lbdq.add(246);
lbdq.add(66);
lbdq.add(292);
lbdq.add(98);
// 创建遍历 lbdq 的迭代器
Iterator<Integer> lbdqIter = lbdq.iterator();
// 将 lbdq 的元素打印到控制台上
System.out.println("The LinkedBlockingDeque, lbdq contains:");
for(int i = 0; i<lbdq.size(); i++)
{
System.out.print(lbdqIter.next() + " ");
}
}
}
输出
The LinkedBlockingDeque, lbdq contains:
166 246 66 292 98