JAVA：常用的队列指南

news2024/12/26 22:59:59

1、简述

在计算机科学中，队列是一种常见的线性数据结构，它遵循先进先出（FIFO，First In First Out）的原则。队列在各种应用中广泛使用，例如任务调度、消息队列和宽度优先搜索等。在 Java 中，队列是 java.util 包的一部分，并且 Java 提供了多种类型的队列以满足不同的需求。本文将详细介绍不同类型的队列及其使用示例。
在这里插入图片描述

2、基本队列接口

在 Java 中，队列由 Queue 接口表示。这个接口定义了一些基本的队列操作，例如插入、删除和检查元素。

import java.util.Queue;
import java.util.LinkedList;

public class BasicQueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 插入元素
        queue.add(1);
        queue.add(2);
        queue.add(3);

        // 检查队列头部元素
        System.out.println("队列头部元素: " + queue.peek());

        // 删除元素
        System.out.println("移除的元素: " + queue.poll());

        // 打印队列元素
        System.out.println("队列元素: " + queue);
    }
}

3、常见的队列实现

3.1 链表队列（LinkedList）

LinkedList 类实现了 Queue 接口。它是一个双向链表，因此可以在常数时间内添加和删除元素。

import java.util.Queue;
import java.util.LinkedList;

public class LinkedListQueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        queue.add("A");
        queue.add("B");
        queue.add("C");

        System.out.println("LinkedList队列: " + queue);
        System.out.println("移除元素: " + queue.poll());
        System.out.println("LinkedList队列: " + queue);
    }
}

3.2 优先队列（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.add(5);
        priorityQueue.add(1);
        priorityQueue.add(3);

        System.out.println("PriorityQueue队列: " + priorityQueue);
        System.out.println("移除元素: " + priorityQueue.poll());
        System.out.println("PriorityQueue队列: " + priorityQueue);
    }
}

3.3 阻塞队列（BlockingQueue）

BlockingQueue 是一个线程安全的队列，支持阻塞插入和删除操作。常见的实现有 ArrayBlockingQueue、LinkedBlockingQueue 和 PriorityBlockingQueue。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.put("X");
        blockingQueue.put("Y");
        blockingQueue.put("Z");

        System.out.println("BlockingQueue队列: " + blockingQueue);
             System.out.println("移除元素: " + blockingQueue.take());
        System.out.println("BlockingQueue队列: " + blockingQueue);
    }
}

3.4 双端队列（Deque）

Deque（Double Ended Queue）是一个可以从两端插入和移除元素的队列。常见的实现有 LinkedList 和 ArrayDeque。

import java.util.Deque;
import java.util.LinkedList;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new LinkedList<>();

        deque.addFirst("A");
        deque.addLast("B");
        deque.addFirst("C");

        System.out.println("Deque队列: " + deque);
        System.out.println("移除头部元素: " + deque.pollFirst());
        System.out.println("移除尾部元素: " + deque.pollLast());
        System.out.println("Deque队列: " + deque);
    }
}

4、队列的实际应用

4.1 任务调度器

队列在任务调度器中非常有用，可以用于管理任务的执行顺序。下面是一个简单的任务调度器示例：

import java.util.LinkedList;
import java.util.Queue;

class Task {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    public void execute() {
        System.out.println("执行任务: " + name);
    }
}

public class TaskScheduler {
    private Queue<Task> taskQueue;

    public TaskScheduler() {
        taskQueue = new LinkedList<>();
    }

    public void addTask(Task task) {
        taskQueue.add(task);
    }

    public void executeTasks() {
        while (!taskQueue.isEmpty()) {
            Task task = taskQueue.poll();
            task.execute();
        }
    }

    public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler();
        scheduler.addTask(new Task("任务1"));
        scheduler.addTask(new Task("任务2"));
        scheduler.addTask(new Task("任务3"));

        scheduler.executeTasks();
    }
}

4.2 消息队列

消息队列用于在分布式系统中传递消息。以下是一个使用 BlockingQueue 实现的简单消息队列示例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class Producer implements Runnable {
    private BlockingQueue<String> queue;

    public Producer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            queue.put("消息1");
            System.out.println("生产者发送: 消息1");
            Thread.sleep(1000);
            queue.put("消息2");
            System.out.println("生产者发送: 消息2");
            Thread.sleep(1000);
            queue.put("消息3");
            System.out.println("生产者发送: 消息3");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Consumer implements Runnable {
    private BlockingQueue<String> queue;

    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                String message = queue.take();
                System.out.println("消费者接收: " + message);
                Thread.sleep(2000);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class MessageQueueExample {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);

        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

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