Java 用两个栈实现队列，两个队列实现栈

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

一：用两个栈实现队列

import java.util.Stack;

public class StackToQueue<T> {
    private Stack<T> stack1;
    private Stack<T> stack2;
    
    public StackToQueue(){
        this.stack1 = new Stack<T>();
        this.stack2 = new Stack<T>();
    }
    public T get() {
        if(this.stack2.size() != 0) {
            return this.stack2.pop();
        }else {
            while(this.stack1.size() != 0) {
                this.stack2.push(this.stack1.pop());
            }
            return this.stack2.pop();
        }
    }
    
    public boolean add(T element) {
        this.stack1.push(element);
        return true;
    }
    public int size() {
        return this.stack1.size() + this.stack2.size();
    }
    
}   

二：用两个队列实现栈

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

public class QueueToStack<T> {
    private Queue<T> queue1;
    private Queue<T> queue2;
    
    public QueueToStack() {
        this.queue1 = new LinkedList<T>();
        this.queue2 = new LinkedList<T>();
    }
    
    public boolean push(T element) {
        this.queue1.add(element);
        return true;
    }
    public T pop() {
        if(this.queue1.size() == 1) {
            return this.queue1.poll();
        }else {
            while(this.queue1.size() > 1) {
                this.queue2.add(this.queue1.poll());
            }
            T ans = this.queue1.poll();
            while(this.queue2.size() > 0) {
                this.queue1.add(this.queue2.poll());
            }
            return ans;
        }
    }
    public int size() {
        return this.queue1.size() + this.queue2.size();
    }
}