Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque

Miaow.Y.Hu

已于 2024-03-07 09:21:04 修改

阅读量2k

点赞数 28

分类专栏： # Java集合文章标签： java 网络协议网络

于 2024-02-29 17:08:31 首次发布

本文链接：https://blog.csdn.net/qq_45922256/article/details/136374992

版权

Java集合专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java 中的 Deque（双端队列）是一种具有队列和栈特性的数据结构，它允许在两端进行插入和删除操作。Deque 接口是 Java 集合框架中的一部分，它定义了双端队列的基本操作。

BlockingDeque 接口： BlockingDeque 接口是 Deque 接口的子接口，它表示一个支持阻塞操作的双端队列。它定义了一些阻塞方法，如 putFirst(), putLast(), takeFirst(), takeLast() 等，这些方法在队列满或空时会阻塞线程。

LinkedBlockingDeque 类： LinkedBlockingDeque 类是 BlockingDeque 接口的一个实现，它基于链表实现了一个无界的阻塞双端队列。它支持并发访问，并提供了阻塞的插入和删除操作。由于它是无界队列，因此可以根据需要添加任意数量的元素。

ArrayDeque 类： ArrayDeque 类是 Deque 接口的一个实现，它基于数组实现了一个双端队列。它支持并发访问，并提供了高效的插入和删除操作。ArrayDeque 是一个动态调整大小的数组，可以根据需要自动增加或缩小容量。

Deque

在这里插入图片描述

Deque 接口： Deque 接口是 Java 集合框架中双端队列的根接口。它扩展了 Queue 接口，并添加了从两端操作队列的方法，如 addFirst(), addLast(), removeFirst(), removeLast() 等。

addFirst(E e)：在双端队列的开头插入指定元素。
addLast(E e)：在双端队列的末尾插入指定元素。
removeFirst()：移除并返回双端队列的第一个元素。
removeLast()：移除并返回双端队列的最后一个元素。
getFirst()：获取双端队列的第一个元素，但不移除。
getLast()：获取双端队列的最后一个元素，但不移除。
peekFirst()：获取双端队列的第一个元素，如果队列为空则返回 null。
peekLast()：获取双端队列的最后一个元素，如果队列为空则返回 null。
…

在这里插入图片描述
Deque 接口有多个实现类，常用的有：

ArrayDeque：基于数组实现的双端队列，它是一个动态调整大小的数组，可以根据需要自动增加或缩小容量。
LinkedList：基于链表实现的双端队列，它提供了高效的插入和删除操作，但访问元素的性能较低。
LinkedBlockingDeque：基于链表实现的无界阻塞双端队列，它支持并发访问，并提供了阻塞的插入和删除操作。

import java.util.Deque;
import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
        deque.addFirst(1);
        deque.addLast(2);
        deque.addFirst(3);
        System.out.println(deque); // 输出 [3, 1, 2]
        
        int first = deque.removeFirst();
        System.out.println(first); // 输出 3
        
        int last = deque.removeLast();
        System.out.println(last); // 输出 2
        
        int peekFirst = deque.peekFirst();
        System.out.println(peekFirst); // 输出 1
        
        int peekLast = deque.peekLast();
        System.out.println(peekLast); // 输出 1
        
        System.out.println(deque); // 输出 [1]
    }
}

我们创建了一个 ArrayDeque 对象，并使用 addFirst() 和 addLast() 方法在双端队列的开头和末尾插入元素。然后使用 removeFirst() 和 removeLast() 方法移除元素。使用 peekFirst() 和 peekLast() 方法获取元素但不移除。最后输出双端队列的内容。

BlockingDeque

他是Java集合中的一个接口，是Deque的子接口，表示一个支持阻塞操作的双向队列。BlockingDeque 继承了 Deque 接口的所有方法，并添加了一些阻塞方法，这些方法在队列满或空时会阻塞线程，直到队列可用或有元素可用时才会继续执行。
在这里插入图片描述

putFirst(E e)：将指定元素插入到双端队列的开头，如果队列已满，则阻塞当前线程直到队列可用。
putLast(E e)：将指定元素插入到双端队列的末尾，如果队列已满，则阻塞当前线程直到队列可用。
takeFirst()：移除并返回双端队列的第一个元素，如果队列为空，则阻塞当前线程直到有元素可用。
takeLast()：移除并返回双端队列的最后一个元素，如果队列为空，则阻塞当前线程直到有元素可。
offerFirst(E e, long timeout, TimeUnit unit)：将指定元素插入到双端队列的开头，如果队列已满，则阻塞当前线程一段时间，直到超时或队列可用。
offerLast(E e, long timeout, TimeUnit unit)：将指定元素插入到双端队列的末尾，如果队列已满，则阻塞当前线程一段时间，直到超时或队列可用。
pollFirst(long timeout, TimeUnit unit)：移除并返回双端队列的第一个元素，如果队列为空，则阻塞当前线程一段时间，直到超时或有元素可用。
pollLast(long timeout, TimeUnit unit)：移除并返回双端队列的最后一个元素，如果队列为空，则阻塞当前线程一段时间，直到超时或有元素可用。

其他方法：
在这里插入图片描述

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class Main {
    public static void main(String[] args) {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>(2);
        try {
            blockingDeque.putFirst(1);
            blockingDeque.putLast(2);
            System.out.println(blockingDeque); // 输出 [1, 2]
            
            blockingDeque.putFirst(3); // 阻塞当前线程，直到队列可用
            blockingDeque.putLast(4); // 阻塞当前线程，直到队列可用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建了一个容量为 2 的 LinkedBlockingDeque 对象，并使用 putFirst() 和 putLast() 方法向双端队列中插入元素。当队列已满时，putFirst() 和 putLast() 方法会阻塞当前线程，直到队列可用。

由于我们的队列容量为 2，并且已经插入了两个元素，所以在插入第三个和第四个元素时，当前线程会被阻塞，直到队列中有空间可用。

LinkedBlockingDeque

LinkedBlockingDeque是Java中的一个双向链表阻塞队列，它实现了BlockingQueue接口，可以用于实现生产者-消费者模式等多线程场景。在本篇博客中，我将详细介绍LinkedBlockingDeque的特性、用法以及示例代码。

在这里插入图片描述

LinkedBlockingDeque的常用方法

add(E e)：将指定元素添加到队列的尾部，如果队列已满，则抛出IllegalStateException异常。
offer(E e)：将指定元素添加到队列的尾部，如果队列已满，则返回false。
put(E e)：将指定元素添加到队列的尾部，如果队列已满，则阻塞直到队列有空间可用。
offerFirst(E e)：将指定元素添加到队列的头部，如果队列已满，则返回false。
offerLast(E e)：将指定元素添加到队列的尾部，如果队列已满，则返回false。
poll()：获取并移除队列头部的元素，如果队列为空，则返回null。
poll(long timeout, TimeUnit unit)：在指定的时间内等待，获取并移除队列头部的元素，如果超时仍未有元素可用，则返回null。
take()：获取并移除队列头部的元素，如果队列为空，则阻塞直到队列非空。
pollFirst()：获取并移除队列头部的元素，如果队列为空，则返回null。
pollLast()：获取并移除队列尾部的元素，如果队列为空，则返回null。
peek()：获取但不移除队列头部的元素，如果队列为空，则返回null。
peekFirst()：获取但不移除队列头部的元素，如果队列为空，则返回null。
peekLast()：获取但不移除队列尾部的元素，如果队列为空，则返回null。
remove(Object o)：从队列中移除指定元素，如果存在该元素则返回true，否则返回false。
contains(Object o)：判断队列是否包含指定元素，如果包含则返回true，否则返回false。

其他方法：
在这里插入图片描述

LinkedBlockingDeque的特性

双向链表结构：LinkedBlockingDeque内部采用双向链表实现，可以高效地支持在队列两端的插入和删除操作。
阻塞操作：当队列为空时，从队列中获取元素的操作会被阻塞，直到队列中有元素可用；当队列已满时，向队列中添加元素的操作也会被阻塞，直到队列有空间可用。
无界队列：LinkedBlockingDeque在构造时可以选择是否设置队列的容量限制，如果不设置容量限制，则队列大小理论上可以无限增长。

LinkedBlockingDeque的使用

创建LinkedBlockingDeque对象

LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<>();

添加元素到队列

deque.add("Element 1"); // 添加元素到队列尾部
deque.offerFirst("Element 2"); // 添加元素到队列头部

获取并移除队列元素

String element = deque.poll(); // 获取并移除队列头部元素
String lastElement = deque.pollLast(); // 获取并移除队列尾部元素

获取但不移除队列元素

String peekElement = deque.peek(); // 获取但不移除队列头部元素
String peekLastElement = deque.peekLast(); // 获取但不移除队列尾部元素

阻塞操作

String element = deque.take(); // 阻塞直到队列非空，然后获取并移除队列头部元素
deque.put("Element 3"); // 阻塞直到队列有空间可用，然后添加元素到队列尾部

示例代码

下面是一个简单的生产者-消费者示例，使用LinkedBlockingDeque作为共享队列：

import java.util.concurrent.LinkedBlockingDeque;

public class ProducerConsumerExample {
    private static LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>();

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int num = queue.take();
                    System.out.println("Consumed: " + num);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

LinkedBlockingDeque是一个功能强大的双向链表阻塞队列，适用于多线程生产者-消费者模式等场景。通过阻塞操作和双向链表结构，它能够高效地支持并发操作。在实际应用中，可以根据具体需求选择合适的队列实现来提升系统性能和可靠性。

ArrayDeque

ArrayDeque的特性

在这里插入图片描述

数组实现：ArrayDeque内部使用数组来存储元素，可以高效地支持在队列两端的插入和删除操作。
双端队列：ArrayDeque既可以作为队列使用，也可以作为栈使用。它支持在队列的头部和尾部进行元素的插入和删除，因此可以灵活地满足不同的需求。
无界队列：ArrayDeque在构造时不需要指定容量大小，它的大小会根据实际元素的数量自动调整，理论上可以无限增长。
非线程安全：ArrayDeque不是线程安全的，如果需要在多线程环境下使用，需要进行适当的同步处理。

注意

非线程安全：ArrayDeque不是线程安全的，如果需要在多线程环境下使用，需要进行适当的同步处理。可以使用Collections.synchronizedDeque()方法创建一个线程安全的ArrayDeque。
不支持null元素：ArrayDeque不支持存储null元素，如果尝试添加null元素，会抛出NullPointerException异常。
避免频繁调整容量：ArrayDeque的内部实现是通过循环数组来存储元素，当队列的容量不足时，会自动进行扩容。在频繁添加或删除元素的场景下，可能会导致多次扩容，影响性能。如果事先能够大致估计队列的大小，可以通过构造函数ArrayDeque(int numElements)来指定初始容量，避免频繁的容量调整。
适用于频繁操作两端的场景：ArrayDeque的优势在于支持高效地在队列的两端进行插入和删除操作。如果只需要在队列的一端进行操作，建议使用LinkedList或ArrayBlockingQueue等其他队列实现。
注意栈操作的顺序：如果将ArrayDeque用作栈使用，需要注意栈操作的顺序。使用push()方法将元素添加到栈顶，使用pop()方法移除并返回栈顶元素。栈操作需要保持一致的顺序，否则可能导致元素顺序的混乱。
避免过度依赖索引操作：由于ArrayDeque是基于数组实现的，它支持通过索引来访问元素。但是，在频繁插入和删除元素的场景下，使用索引操作可能会导致性能下降。因此，在使用ArrayDeque时，应尽量避免过度依赖索引操作，而是使用队列提供的方法来操作元素。

在这里插入图片描述

ArrayDeque的使用

创建ArrayDeque对象

ArrayDeque<String> deque = new ArrayDeque<>();

添加元素到队列

deque.add("Element 1"); // 添加元素到队列尾部
deque.offerFirst("Element 2"); // 添加元素到队列头部

获取并移除队列元素

String element = deque.poll(); // 获取并移除队列头部元素
String lastElement = deque.pollLast(); // 获取并移除队列尾部元素

获取但不移除队列元素

String peekElement = deque.peek(); // 获取但不移除队列头部元素
String peekLastElement = deque.peekLast(); // 获取但不移除队列尾部元素

栈操作

deque.push("Element 3"); // 将元素添加到栈顶
String popElement = deque.pop(); // 移除并返回栈顶元素

示例代码

import java.util.ArrayDeque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        ArrayDeque<String> queue = new ArrayDeque<>();
        queue.offer("Element 1");
        queue.offer("Element 2");

        System.out.println(queue.poll()); // 输出: Element 1

        ArrayDeque<String> stack = new ArrayDeque<>();
        stack.push("Element 3");
        stack.push("Element 4");

        System.out.println(stack.pop()); // 输出: Element 4
    }
}

ArrayDeque是一个非常实用的双端队列，可以灵活地支持队列和栈的操作。通过数组实现和双端插入和删除操作，它能够高效地满足不同场景下的需求。在实际应用中，可以根据具体需求选择合适的队列实现来提升系统性能和可靠性。

Miaow.Y.Hu

关注

28
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque

Java 中的 Deque（双端队列）是一种具有队列和栈特性的数据结构，它允许在两端进行插入和删除操作。Deque 接口是 Java 集合框架中的一部分，它定义了双端队列的基本操作。 BlockingDeque 接口： BlockingDeque 接口是 Deque 接口的子接口，它表示一个支持阻塞操作的双端队列。它定义了一些阻塞方法，如 putFirst(), putLast(), takeFirst(), takeLast() 等，这些方法在队列满或空时会阻塞线程。
复制链接

扫一扫