使用LinkedList类实现创建一个队列Queue类。 （1） 包含一个LinkedList对象。 （2）实现入队的时候在队尾添加。 （3） 实现出队的时候在队首删除。

好的，我会按照您的要求进行回答。

import java.util.LinkedList;

public class Queue<T> {
    // 包含一个LinkedList对象
    private LinkedList<T> list;

    // 构造函数
    public Queue() {
        list = new LinkedList<T>();
    }

    // 实现入队的时候在队尾添加
    public void enqueue(T item) {
        list.addLast(item);
    }

    // 实现出队的时候在队首删除
    public T dequeue() {
        return list.removeFirst();
    }
}

这里我们使用了泛型，使得队列可以存储任意类型的数据。enqueue方法用于入队，在队列的末尾添加元素；dequeue方法用于出队，在队列的头部删除元素。

相关问题

如何使用Java编程语言通过组合技巧实现 LinkedList 的封装，来创建一个遵循后进先出原则的栈类（Stack）和一个遵循先进后出原则的队列类（Queue），并且提供一个测试类来验证其功能？请详细展示相关代码和测试步骤。

在Java中，我们可以通过继承和组合的方式分别创建一个Stack和一个Queue。这里我们将使用LinkedList作为底层数据结构，因为LinkedList本身就支持在两端添加和删除元素。

首先，创建一个`AbstractCollection`类作为基类，包含基本的增删元素操作：

import java.util.LinkedList;
import java.util.List;

public abstract class AbstractCollection<T> {
    private List<T> elements = new LinkedList<>();

    public void push(T item) {
        elements.add(item);
    }

    public T pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Cannot pop from an empty collection.");
        }
        return elements.remove(elements.size() - 1);
    }

    public T peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Cannot peek at an empty collection.");
        }
        return elements.get(elements.size() - 1);
    }

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

    // 其他辅助方法...

    protected List<T> getElements() {
        return elements;
    }
}

接着，创建Stack类，继承自`AbstractCollection`并实现后进先出原则：

public class Stack<T> extends AbstractCollection<T> {
    @Override
    public void push(T item) {
        super.push(item);
    }

    // 省略pop()和peek()方法
}

然后，创建Queue类，同样继承自`AbstractCollection`，但实现先进后出原则，这通常会涉及一个额外的数据结构如双向链表，这里简化为使用LinkedList的头部作为队首：

public class Queue<T> extends AbstractCollection<T> {
    @Override
    public void push(T item) {
        elements.addFirst(item); // 使用addFirst添加到队首
    }

    @Override
    public T pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Cannot pop from an empty queue.");
        }
        return elements.removeLast(); // 使用removeLast移除并返回队尾元素
    }

    // 省略peek()方法
}

最后，创建一个测试类来验证这两个容器的功能：

import org.junit.Test;

public class CollectionsTest {
    @Test
    public void testStack() {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        assertEquals(3, stack.pop()); // 验证后进先出原则
        assertEquals(2, stack.peek()); // 验证队列头元素
    }

    @Test
    public void testQueue() {
        Queue<Integer> queue = new Queue<>();
        queue.push(1);
        queue.push(2);
        queue.push(3);

        assertEquals(1, queue.pop()); // 验证先进先出原则
        assertEquals(2, queue.peek()); // 验证队列头元素
    }
}

运行这个测试类，如果所有测试方法都通过，那么我们的Stack和Queue实现了预期的功能。

如何使用Java的组合对（LinkedList）类进行封装，分别实现一个栈(Stack)和队列(Queue)，并编写一个测试类来验证其功能是否正确。

在Java中，我们可以利用`LinkedList`类作为基础数据结构来实现栈(Stack)和队列(Queue)。这里我会提供一种简单的方式：

首先，我们创建一个名为`Node`的内部类，用于存储节点数据：

import java.util.LinkedList;

class Node<T> {
    T data;
    LinkedList<Node<T>> next;

    public Node(T data) {
        this.data = data;
        this.next = new LinkedList<>();
    }
}

接下来，我们将实现栈和队列的接口：

public class MyStack<T> {
    private Node<T> top;

    // 添加元素到顶部
    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next.add(top);
        top = newNode;
    }

    // 删除并返回顶部元素
    public T pop() {
        if (top == null) throw new IllegalStateException("Stack is empty");
        T item = top.data;
        top = top.next.head();
        return item;
    }

    // 检查栈是否为空
    public boolean isEmpty() {
        return top == null;
    }
}

public class MyQueue<T> {
    private Node<T> front, rear;

    // 添加元素到队尾
    public void enqueue(T item) {
        if (rear == null) {
            rear = front = new Node<>(item);
        } else {
            rear.next = new Node<>(item);
            rear = rear.next;
        }
    }

    // 从队首删除并返回元素
    public T dequeue() {
        if (front == null) throw new IllegalStateException("Queue is empty");
        T item = front.data;
        Node<T> temp = front;
        front = front.next;
        if (front == null) rear = null;
        return item;
    }

    // 检查队列是否为空
    public boolean isEmpty() {
        return front == null;
    }
}

为了验证它们的功能，我们可以创建一个测试类`MyStackAndQueueTest`：

import org.junit.Test;
import static org.junit.Assert.*;

public class MyStackAndQueueTest {
    @Test
    public void testStack() {
        MyStack<Integer> stack = new MyStack<>();
        stack.push(1);
        stack.push(2);
        assertEquals(1, stack.pop());
        assertEquals(2, stack.pop());
        assertTrue(stack.isEmpty());
    }

    @Test
    public void testQueue() {
        MyQueue<Integer> queue = new MyQueue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        assertEquals(1, queue.dequeue());
        assertEquals(2, queue.dequeue());
        assertTrue(queue.isEmpty());
    }
}

这个测试类通过添加和删除元素来检查栈和队列的基本操作是否正确。