java代码怎样用链表实现链式队列 java代码链式队列结构的应用实现技巧​

public class LinkedQueue<T> {

    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data) {
            this.data = data;
            this.next = null;
        }
    }

    private Node<T> head; // 队头
    private Node<T> tail; // 队尾
    private int size;

    public LinkedQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    public boolean isEmpty() {
        return head == null; // 或者 size == 0;
    }

    public int size() {
        return size;
    }

    public void enqueue(T data) {
        Node<T> newNode = new Node<>(data);
        if (isEmpty()) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }

    public T dequeue() {
        if (isEmpty()) {
            return null; // 或者抛出异常，根据实际情况选择
        }
        T data = head.data;
        head = head.next;
        if (head == null) {
            tail = null; // 队列为空时，tail也要置空
        }
        size--;
        return data;
    }

    public T peek() {
        if (isEmpty()) {
            return null; // 或者抛出异常
        }
        return head.data;
    }

    public static void main(String[] args) {
        LinkedQueue<Integer> queue = new LinkedQueue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);

        System.out.println("Queue size: " + queue.size()); // Output: Queue size: 3
        System.out.println("Dequeue: " + queue.dequeue()); // Output: Dequeue: 1
        System.out.println("Peek: " + queue.peek());       // Output: Peek: 2
        System.out.println("Queue size: " + queue.size()); // Output: Queue size: 2
    }
}

synchronized

java.util.concurrent

ConcurrentLinkedQueue

ConcurrentLinkedQueue

import java.util.concurrent.ConcurrentLinkedQueue;

public class ThreadSafeLinkedQueue<T> {

    private ConcurrentLinkedQueue<T> queue = new ConcurrentLinkedQueue<>();

    public void enqueue(T data) {
        queue.offer(data);
    }

    public T dequeue() {
        return queue.poll();
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadSafeLinkedQueue<Integer> queue = new ThreadSafeLinkedQueue<>();

        // 多个线程向队列中添加元素
        Thread producer1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                queue.enqueue(i);
                System.out.println("Producer 1 enqueue: " + i);
                try {
                    Thread.sleep(100); // 模拟生产过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread producer2 = new Thread(() -> {
            for (int i = 10; i < 20; i++) {
                queue.enqueue(i);
                System.out.println("Producer 2 enqueue: " + i);
                try {
                    Thread.sleep(150); // 模拟生产过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 单个线程从队列中取出元素
        Thread consumer = new Thread(() -> {
            while (!queue.isEmpty() || producer1.isAlive() || producer2.isAlive()) {
                Integer data = queue.dequeue();
                if (data != null) {
                    System.out.println("Consumer dequeue: " + data);
                }
                try {
                    Thread.sleep(200); // 模拟消费过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Consumer finished.");
        });

        producer1.start();
        producer2.start();
        consumer.start();

        producer1.join();
        producer2.join();
        consumer.join();

        System.out.println("Main thread finished.");
    }
}