Java中如何实现栈和队列并提供相关操作的函数？

在Java中，可以通过数组或者链表来实现栈和队列。

栈的实现：

数组实现栈：

public class ArrayStack {
    private int[] stack; //栈数组
    private int top; //栈顶位置
    private int maxSize; //栈大小

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
        top = -1;
    }

    //入栈
    public boolean push(int x) {
        if (isFull()) {
            System.out.println("栈已满！");
            return false;
        }
        stack[++top] = x;
        return true;
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            System.out.println("栈为空！");
            return -1;
        }
        return stack[top--];
    }

    //判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }

    //判断栈是否已满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //返回栈顶元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("栈为空！");
            return -1;
        }
        return stack[top];
    }

    //返回栈中元素个数
    public int size() {
        return top + 1;
    }
}

链表实现栈：

public class LinkedStack {
    private Node top; //栈顶节点
    private int size; //栈大小

    private class Node {
        private int val;
        private Node next;

        public Node(int val) {
            this.val = val;
        }
    }

    //入栈
    public void push(int x) {
        Node node = new Node(x);
        node.next = top;
        top = node;
        size++;
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            System.out.println("栈为空！");
            return -1;
        }
        int val = top.val;
        top = top.next;
        size--;
        return val;
    }

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

    //返回栈顶元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("栈为空！");
            return -1;
        }
        return top.val;
    }

    //返回栈中元素个数
    public int size() {
        return size;
    }
}

队列的实现：

数组实现队列：

public class ArrayQueue {
    private int[] queue; //队列数组
    private int front; //队头指针
    private int rear; //队尾指针
    private int maxSize; //队列大小

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        queue = new int[maxSize];
        front = rear = 0;
    }

    //入队
    public boolean enqueue(int x) {
        if (isFull()) {
            System.out.println("队列已满！");
            return false;
        }
        queue[rear++] = x;
        return true;
    }

    //出队
    public int dequeue() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return -1;
        }
        return queue[front++];
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return front == rear;
    }

    //判断队列是否已满
    public boolean isFull() {
        return rear == maxSize;
    }

    //返回队头元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return -1;
        }
        return queue[front];
    }

    //返回队列中元素个数
    public int size() {
        return rear - front;
    }
}

链表实现队列：

public class LinkedQueue {
    private Node front; //队头节点
    private Node rear; //队尾节点
    private int size; //队列大小

    private class Node {
        private int val;
        private Node next;

        public Node(int val) {
            this.val = val;
        }
    }

    //入队
    public void enqueue(int x) {
        Node node = new Node(x);
        if (rear == null) {
            front = rear = node;
        } else {
            rear.next = node;
            rear = node;
        }
        size++;
    }

    //出队
    public int dequeue() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return -1;
        }
        int val = front.val;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        size--;
        return val;
    }

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

    //返回队头元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return -1;
        }
        return front.val;
    }

    //返回队列中元素个数
    public int size() {
        return size;
    }
}

以上就是实现栈和队列的方法，可以根据需要选择适合自己的方法。通过这些实现，可以方便地对栈和队列进行各种操作。