用顺序队列实现栈功能

//创建类继承栈的接口，在类中用队列实现栈的功能方法，Stack接口详见栈接口及顺序栈的实现
类中需创建两个顺序栈的对象，ArrayQueue类见队列的接口及顺序队列的实现
入栈：和入队一样都是从尾入。
出栈：出栈时因为栈要出的实际是队列的最后一个，所以将除了队尾的元素都入队到第二个队列，再将队尾弹出即是出栈的元素；而其他元素出队到第二个队列时顺序不变，所以出栈完成。
查看队首：和出队相同原理
因为不知道元素在第一个队列还是第二个队列，所以进行操作前要先进行判空，判断元素在哪个队列。

package p2.线性结构;

import p1.接口.Stack;

import java.util.Iterator;
//用队列实现栈功能
public class QueueToStack {
    public static void main(String[] args) {
        StackImplyByQueue<Integer> stack = new StackImplyByQueue<>();
        for (int i = 0;i<5;i++){
            stack.push(i);
        }
        System.out.println(stack);
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

class StackImplyByQueue<E> implements Stack<E>{
    private ArrayQueue<E> queueA;
    private ArrayQueue<E> queueB;
    public StackImplyByQueue(){
        queueA = new ArrayQueue<>();
        queueB = new ArrayQueue<>();
    }
    //查看栈长度
    @Override
    public int size() {
        if (queueA.isEmpty() && queueA.isEmpty()){
            return 0;
        }else if (!queueA.isEmpty()){
            return queueA.size();
        }else {
            return queueB.size();
        }
    }
    //判空
    @Override
    public boolean isEmpty() {
        return queueA.isEmpty() && queueB.isEmpty();
    }
    //入栈
    @Override
    public void push(E element) {
        if (queueA.isEmpty() && queueB.isEmpty()){
            queueA.offer(element);
        }else if (!queueA.isEmpty()){
            queueA.offer(element);
        }else {
            queueB.offer(element);
        }
    }
    //出栈
    @Override
    public E pop() {
        if(isEmpty()){
            throw new IllegalArgumentException("stack is empty");
        }
        E ret = null;
        if (!queueA.isEmpty()){
            while (queueA.size() != 1){
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
        }else {
            while (queueB.size() != 1){
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
        }
        return ret;
    }
    //查看栈顶元素
    @Override
    public E peek() {
        if(isEmpty()){
            throw new IllegalArgumentException("stack is empty");
        }
        E ret = null;
        if (!queueA.isEmpty()){
            while (queueA.size() != 1){
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
            queueB.offer(ret);
        }else {
            while (queueB.size() != 1){
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
            queueA.offer(ret);
        }
        return ret;
    }
    //栈清空
    @Override
    public void clear() {
        queueA.clear();
        queueB.clear();
    }
    //迭代器
    @Override
    public Iterator<E> iterator() {
        if (isEmpty()){
            return queueA.iterator();
        }else if (!queueA.isEmpty()){
            return queueA.iterator();
        }else {
            return queueB.iterator();
        }
    }
    //输出形式
    @Override
    public String toString(){
        if (isEmpty()){
            return "[]";
        }else if (!queueA.isEmpty()){
            return queueA.toString();
        }else {
            return queueB.toString();
        }
    }
}