原创

Java中的队列都有哪些，有什么区别？

引言

在Java中，队列是一种常见的数据结构，用于存储和管理元素。队列按照先入先出（FIFO）的原则进行操作，即最先进入队列的元素最先被取出。本教程将深入探讨Java中的队列，包括队列的接口、实现类、阻塞队列、以及一些实际应用场景的示例代码。

1. 队列的基本概念

1.1 队列的特点

队列是一种基本的数据结构，具有以下特点：

•先入先出（FIFO）： 队列中的元素按照它们进入队列的顺序排列，最先进入的元素最先被取出。•封闭性： 只能在队列的两端进行操作，元素的插入在一端进行，而删除在另一端进行。•线性结构： 队列是一种线性结构，元素的排列形式呈线性序列。

1.2 Queue接口概述

在Java中，队列的基本接口是Queue接口，它继承自Collection接口，与List和Set同属于集合框架。Queue接口定义了一系列操作，包括添加、删除、检索元素等。

import java.util.Queue;

2. 队列的基本实现

2.1 LinkedList实现非阻塞队列

LinkedList是Java中的一个双向链表实现，它实现了Queue接口，可用作非阻塞队列。以下是一个简单的示例：

import java.util.LinkedList;import java.util.Queue;
public class NonBlockingQueueExample {    public static void main(String[] args) {        Queue<String> queue = new LinkedList<>();
        // 添加元素        queue.offer("Element1");        queue.offer("Element2");
        // 获取并移出元素        String element = queue.poll();        System.out.println("Removed Element: " + element);
        // 获取队列头部元素        String peekedElement = queue.peek();        System.out.println("Peeked Element: " + peekedElement);    }}

在上述示例中，我们使用offer添加元素，poll获取并移出元素，peek获取队列头部元素。

2.2 PriorityQueue和ConcurrentLinkedQueue

2.2.1 PriorityQueue示例

PriorityQueue是一个有序列表实现，根据元素的自然排序或提供的比较器进行排序。以下是一个简单的示例：

import java.util.PriorityQueue;import java.util.Queue;
public class PriorityQueueExample {    public static void main(String[] args) {        Queue<Integer> priorityQueue = new PriorityQueue<>();
        // 添加元素        priorityQueue.offer(3);        priorityQueue.offer(1);        priorityQueue.offer(2);
        // 获取并移出元素（按优先级）        while (!priorityQueue.isEmpty()) {            System.out.println("Removed Element with Priority: " + priorityQueue.poll());        }    }}

2.2.2 ConcurrentLinkedQueue示例

ConcurrentLinkedQueue是一个基于链接节点的线程安全队列。以下是一个简单的示例：

import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;
public class ConcurrentLinkedQueueExample {    public static void main(String[] args) {        Queue<String> concurrentQueue = new ConcurrentLinkedQueue<>();
        // 添加元素        concurrentQueue.offer("Element1");        concurrentQueue.offer("Element2");
        // 获取并移出元素        String element = concurrentQueue.poll();        System.out.println("Removed Element: " + element);    }}

2.3 阻塞队列的实现

Java提供了BlockingQueue接口及其实现类，用于实现阻塞队列，即在队列满或空时进行阻塞。

2.3.1 ArrayBlockingQueue示例

ArrayBlockingQueue是一个由数组支持的有界队列，以下是一个简单的示例：

import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;
public class ArrayBlockingQueueExample {    public static void main(String[] args) {        BlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        // 添加元素        arrayBlockingQueue.offer("Element1");        arrayBlockingQueue.offer("Element2");
        // 获取并移出元素        String element = arrayBlockingQueue.poll();        System.out.println("Removed Element: " + element);    }}

2.3.2 LinkedBlockingQueue示例

LinkedBlockingQueue是一个由链接节点支持的可选有界队列，以下是一个简单的示例：

import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;
public class LinkedBlockingQueueExample {    public static void main(String[] args) {        BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<>();
        // 添加元素        linkedBlockingQueue.offer("Element1");        linkedBlockingQueue.offer("Element2");
        // 获取并移出元素        String element = linkedBlockingQueue.poll();        System.out.println("Removed Element: " + element);    }}

2.3.3 其他阻塞队列示例

除了ArrayBlockingQueue和LinkedBlockingQueue之外，Java还提供了PriorityBlockingQueue、DelayQueue和SynchronousQueue等阻塞队列的实现。

3. 阻塞队列的操作

阻塞队列的操作可以根据它们的响应方式分为以下三类：

•add、remove、element：在试图为一个已满的队列增加元素或从空队列取得元素时抛出异常。适合用于不需要考虑多线程同步的场景。

BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(2);
// 添加元素（队列已满，抛出异常）blockingQueue.add("Element1");blockingQueue.add
("Element2");

•offer、poll、peek：在无法完成任务时只是给出一个错误提示而不会抛出异常。适合用于多线程环境。

BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(2);
// 添加元素（队列已满，返回false）boolean added = blockingQueue.offer("Element1");boolean addedAgain = blockingQueue.offer("Element2");
// 获取并移出元素String element = blockingQueue.poll();

•put、take：阻塞操作，在队列满时阻塞 put操作，在队列空时阻塞take操作。

BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(2);
// 添加元素（队列已满，阻塞）blockingQueue.put("Element1");blockingQueue.put("Element2");
// 获取并移出元素（队列为空，阻塞）String element = blockingQueue.take();

4. 实际应用示例

4.1 生产者-消费者模型

下面是一个简单的生产者-消费者模型的示例，使用BlockingQueue来实现线程安全的队列操作。

import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;
public class ProducerConsumerExample {    public static class Basket {        BlockingQueue<String> basket = new LinkedBlockingQueue<>(3);
        public void produce() throws InterruptedException {            basket.put("An apple");        }
        public String consume() throws InterruptedException {            return basket.take();        }
        public int getAppleNumber() {            return basket.size();        }    }
    public static void main(String[] args) {        final Basket basket = new Basket();
        // 定义生产者        class Producer implements Runnable {            public void run() {                try {                    while (true) {                        System.out.println("Producer is ready to produce an apple.");                        basket.produce();                        System.out.println("Producer has produced an apple. Current apples: " + basket.getAppleNumber());                        Thread.sleep(300);                    }                } catch (InterruptedException ex) {                    ex.printStackTrace();                }            }        }
        // 定义消费者        class Consumer implements Runnable {            public void run() {                try {                    while (true) {                        System.out.println("Consumer is ready to consume an apple.");                        basket.consume();                        System.out.println("Consumer has consumed an apple. Current apples: " + basket.getAppleNumber());                        Thread.sleep(1000);                    }                } catch (InterruptedException ex) {                    ex.printStackTrace();                }            }        }
        // 使用线程池执行生产者和消费者任务        ExecutorService service = Executors.newCachedThreadPool();        Producer producer = new Producer();        Consumer consumer = new Consumer();        service.submit(producer);        service.submit(consumer);
        // 等待一段时间后停止任务        try {            Thread.sleep(10000);        } catch (InterruptedException e) {            e.printStackTrace();        }        service.shutdownNow();    }}

结语

通过本教程，我们深入了解了Java中队列的基本概念、接口和实现类，以及阻塞队列的使用方式。队列作为一种常见的数据结构，被广泛应用于多线程编程、任务调度等场景。通过示例代码和详细解释，希望读者能够轻松理解并运用队列在实际项目中。

备注

备注: 关注站长获取更多详情。

正文到此结束

所属分类：java容器

本文标签： Java 面试题
本文链接： https://www.jietongc.com/article/341
版权声明： 本文由大熊科技原创发布，转载请遵循《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》许可协议授权