下面是实现Java队列数据结构的完整攻略。

Java队列数据结构的实现

1. 概述

队列是一种常用的线性数据结构，是“先进先出”（FIFO）的一种数据结构。队列通常具有两个操作：入队和出队，它们分别对应着在队列尾添加元素和在队列头删除元素的操作。

在Java中，有多种方式可以实现队列数据结构，本文将讲解两种常用的实现方式：基于数组的实现和基于链表的实现。

2. 基于数组的实现

基于数组的实现是最简单的实现方式之一，它的基本思路是使用一个固定大小的数组来存储队列中的元素，通过维护队列头和队列尾两个指针来实现队列的入队和出队。

具体实现步骤如下：

1. 定义一个固定大小的数组和两个指针front和rear，初始时都指向0。
2. 入队操作：将元素添加到rear指针所在的位置，如果队列已满则抛出队列满异常。
3. 出队操作：取走front指针所指向的元素，如果队列为空则抛出队列空异常。
4. 判断队列是否为空：如果front和rear指向的位置相同，说明队列为空。
5. 判断队列是否已满：如果rear指针所在的位置已经到达了数组的末尾，说明队列已满。

示例代码：

public class ArrayQueue<E> implements Queue<E> {

    private E[] data;
    private int front;
    private int rear;
    private int size;

    public ArrayQueue(int capacity) {
        data = (E[]) new Object[capacity];
        front = 0;
        rear = 0;
        size = 0;
    }

    public ArrayQueue() {
        this(10);
    }

    @Override
    public void enqueue(E element) {
        if (size == data.length) {
            throw new IllegalStateException("Queue is full");
        }
        data[rear] = element;
        rear = (rear + 1) % data.length;
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        E element = data[front];
        front = (front + 1) % data.length;
        size--;
        return element;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        return data[front];
    }

    @Override
    public int size() {
        return size;
    }

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

}

3. 基于链表的实现

基于链表的实现是另一种常用的实现方式，它的基本思路是使用一个链表来存储队列中的元素，通过维护队列头和队列尾两个指针来实现队列的入队和出队。

具体实现步骤如下：

1. 定义一个链表节点类Node，包含一个元素和一个指向下一个节点的指针。
2. 定义一个队列类LinkedListQueue，包含一个head和一个tail指针，初始时都指向null。
3. 入队操作：将元素添加到tail指针所在的节点的后面，并更新tail指针指向新的节点。
4. 出队操作：取走head指针所指向的节点的元素，并更新head指针指向下一个节点。
5. 判断队列是否为空：如果head指针指向null，则队列为空。
6. 因为链表的长度是动态变化的，所以不需要判断队列是否已满的情况。

示例代码：

public class LinkedListQueue<E> implements Queue<E> {

    private class Node {
        E element;
        Node next;
        public Node(E element, Node next) {
            this.element = element;
            this.next = next;
        }
    }

    private Node head;
    private Node tail;
    private int size;

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

    @Override
    public void enqueue(E element) {
        Node node = new Node(element, null);
        if (isEmpty()) {
            head = node;
        } else {
            tail.next = node;
        }
        tail = node;
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        E element = head.element;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        size--;
        return element;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        return head.element;
    }

    @Override
    public int size() {
        return size;
    }

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

}

4. 总结

队列的实现有多种方式，本文介绍了两种常用的实现方式：基于数组的实现和基于链表的实现。两种实现方式各有优劣，在具体应用中需要根据实际需求选择合适的实现方式。