当前位置：首页 > Java

队列如何使用java

2026-03-24 06:29:33Java

队列的基本概念

队列是一种先进先出（FIFO）的数据结构，元素从队尾入队，从队头出队。Java提供了多种实现队列的方式，包括LinkedList、ArrayDeque和PriorityQueue等。

使用LinkedList实现队列

LinkedList实现了Queue接口，可以直接作为队列使用。

队列如何使用java

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

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

        // 入队操作
        queue.add(10);
        queue.add(20);
        queue.add(30);

        // 出队操作
        int firstElement = queue.remove();
        System.out.println("出队元素: " + firstElement);

        // 查看队头元素
        int peekElement = queue.peek();
        System.out.println("队头元素: " + peekElement);

        // 判断队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("队列是否为空: " + isEmpty);
    }
}

使用ArrayDeque实现队列

ArrayDeque是双端队列，也可以作为普通队列使用，性能通常优于LinkedList。

队列如何使用java

import java.util.ArrayDeque;
import java.util.Queue;

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

        // 入队操作
        queue.offer("Apple");
        queue.offer("Banana");
        queue.offer("Cherry");

        // 出队操作
        String fruit = queue.poll();
        System.out.println("出队元素: " + fruit);

        // 查看队头元素
        String nextFruit = queue.peek();
        System.out.println("队头元素: " + nextFruit);
    }
}

使用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(50);
        priorityQueue.add(10);
        priorityQueue.add(30);

        // 出队操作（按优先级顺序）
        while (!priorityQueue.isEmpty()) {
            System.out.println("出队元素: " + priorityQueue.poll());
        }
    }
}

自定义队列实现

如果需要完全控制队列行为，可以手动实现队列接口。

public class CustomQueue<T> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elements;
    private int front;
    private int rear;
    private int size;

    public CustomQueue() {
        elements = new Object[DEFAULT_CAPACITY];
        front = 0;
        rear = -1;
        size = 0;
    }

    public void enqueue(T item) {
        if (size == elements.length) {
            resize();
        }
        rear = (rear + 1) % elements.length;
        elements[rear] = item;
        size++;
    }

    public T dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("队列为空");
        }
        T item = (T) elements[front];
        front = (front + 1) % elements.length;
        size--;
        return item;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void resize() {
        Object[] newArray = new Object[elements.length * 2];
        for (int i = 0; i < size; i++) {
            newArray[i] = elements[(front + i) % elements.length];
        }
        elements = newArray;
        front = 0;
        rear = size - 1;
    }
}