如何仅用队列结构实现栈结构 和如何仅用栈结构实现队列结构

package basic_class_03;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * 类名：Code_03_StackAndQueueConvert<br>
 * 功能：1.仅用队列结构实现栈结构
 *        2.仅用栈结构实现队列结构br>
 * 作者：java战士<br>
 * 日期：2019/8/22<br>
 * 版本：v1.0.0
 * 历史修订：
 */
public class Code_03_StackAndQueueConvert {
    //用栈结构实现队列结构
    public static class TwoStackQueue{
        private Stack<Integer> stackPush;
        private Stack<Integer> stackPop;

        public TwoStackQueue() {
            this.stackPush = new Stack<Integer>();
            this.stackPop = new Stack<Integer>();
        }
        public void push(int pushInt){
            this.stackPush.push(pushInt);
        }
        public int pop(){
            if (stackPush.empty()&&stackPop.empty()){
                throw new RuntimeException("Queue is empty!");
            }else if (stackPop.empty()){
                while (!stackPush.empty()){
                    stackPop.push(stackPush.pop());
                }
            }
            return stackPop.pop();
        }
        public int peek(){
            if (stackPop.empty()&&stackPush.empty()){
                throw new RuntimeException("Queue is empty!");
            }else if (stackPop.empty()){
                while (!stackPush.empty()){
                    stackPop.push(stackPush.pop());
                }
            }
            return stackPop.pop();
        }
    }

    //用队列实现栈
    public static class TwoQueueStack{
        private Queue<Integer> data;
        private Queue<Integer> help;

        public TwoQueueStack() {
            this.data=new LinkedList<Integer>();
            this.help=new LinkedList<Integer>();
        }
        public void push(int num){
            data.add(num);
        }
        public int pop(){
            if (data.isEmpty()){
                throw new RuntimeException("stack is empty!");
            }
            while (data.size()>1){
                help.add(data.poll());
            }
            int res=data.poll();
            swap();
            return res;

        }
        public int peek() {
            if (data.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            while (data.size() != 1) {
                help.add(data.poll());
            }
            int res = data.poll();
            help.add(res);
            swap();
            return res;
        }
        public void swap(){
            Queue<Integer> tmp=data;
            data=help;
            help=tmp;
        }
    }

    public static void main(String[] args){
        int[] arr=new int[]{1,2,3,4,5,6};
        TwoStackQueue twoStackQueue=new TwoStackQueue();
        System.out.print("栈实现队列：");
        for (int a:arr) {
            twoStackQueue.push(a);
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(twoStackQueue.pop()+" ");
        }
        System.out.println();
        System.out.println("==================");
        TwoQueueStack twoQueueStack=new TwoQueueStack();
        System.out.print("队列实现栈：");
        for (int a:arr) {
            twoQueueStack.push(a);
        }
        for (int i=0;i<arr.length;i++){
            System.out.print(twoQueueStack.pop()+" ");
        }
    }
}

测试结果：