请使用LinkedList来模拟一个堆栈或者队列数据结构。（封装成一个容器类）

以下是使用LinkedList来模拟堆栈和队列的容器类实现：

import java.util.LinkedList;

public class Container<T> {
    private LinkedList<T> list;

    public Container() {
        list = new LinkedList<>();
    }

    // 堆栈操作，入栈
    public void push(T item) {
        list.addFirst(item);
    }

    // 堆栈操作，出栈
    public T pop() {
        if (list.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return list.removeFirst();
    }

    // 堆栈操作，查看栈顶元素
    public T peek() {
        if (list.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return list.getFirst();
    }

    // 队列操作，入队
    public void offer(T item) {
        list.addLast(item);
    }

    // 队列操作，出队
    public T poll() {
        if (list.isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return list.removeFirst();
    }

    // 队列操作，查看队首元素
    public T peekFirst() {
        if (list.isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return list.getFirst();
    }

    // 队列操作，查看队尾元素
    public T peekLast() {
        if (list.isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return list.getLast();
    }

    // 返回容器大小
    public int size() {
        return list.size();
    }

    // 判断容器是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

使用方法：

Container<Integer> stack = new Container<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop()); // 输出 3
System.out.println(stack.pop()); // 输出 2

Container<String> queue = new Container<>();
queue.offer("a");
queue.offer("b");
queue.offer("c");
System.out.println(queue.poll()); // 输出 a
System.out.println(queue.peekFirst()); // 输出 b
System.out.println(queue.peekLast()); // 输出 c