由两个栈组成的队列

import java.util.Scanner;
import java.util.Stack;

public class Main {


    public static void main(String[] args) {

        Queue<Integer>  queue = new Queue<Integer>();

        Scanner scanner = new Scanner(System.in);
        int n = Integer.valueOf(scanner.nextLine());
        String string;
        for (int i = 0; i < n; i++) {
            string = scanner.nextLine();
            if (string.equals("poll")) {
                queue.poll();
            } else if (string.equals("peek")) {
                System.out.println(queue.peek());
            } else {
                queue.offer(Integer.valueOf(string.split(" ")[1]));
            }
        }
    }
}

class Queue<T>{
    private Stack<T> in = new Stack<T>();
    private Stack<T> out = new Stack<T>();

    public synchronized boolean offer(T item) {
        in.push(item);
        return true;
    }


    public synchronized T poll() {

        if (!out.empty()) {
            return out.pop();
        }

        if (in.empty()) {
            return null;
        }

        while (!in.empty()) {
            T t = in.pop();
            out.push(t);
        }

        return out.pop();
    }

    public synchronized T peek(){

        if (!out.empty()) {
            return out.peek();
        }

        if (in.empty()) {
            return null;
        }

        while (!in.empty()) {
            T t = in.pop();
            out.push(t);
        }

        return out.peek();
    }

}

import java.util.*;
import java.io.*;
import java.math.*;

/*
    实现一个特殊功能的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。
*/
public class Main{
    
    public static void main(String[] args) {
        InputReader inputReader = new InputReader();
        PrintWriter printWriter = new PrintWriter(System.out);
        inputReader.nextLine();  // 输入
        int size = inputReader.nextInt(); // 将 String --> int
        TwoStackQueue stack = new TwoStackQueue();

        for (int i = 0; i < size; i++){
            inputReader.nextLine(); // 读取一行
            String operate = inputReader.next();

            if ("add".equals(operate)){
                Integer num = inputReader.nextInt();
                stack.add(num);
            }
            if ("poll".equals(operate)){
                stack.poll();
            }
            if ("peek".equals(operate)){
                printWriter.println(stack.peek());
            }
        }
        printWriter.close();
    }
    
}
 class TwoStackQueue{
    public Stack<Integer> stackPush;
    public Stack<Integer> stackPop;
    
    public TwoStackQueue(){
        stackPush=new Stack<Integer>();
        stackPop=new Stack<Integer>();
    }
    private void pushToPop(){
        if (stackPop.empty()){
            while(!stackPush.empty()){
                stackPop.push(stackPush.pop());
            }
        }
    }
     public void add(int pushInt){
         stackPush.push(pushInt);
         pushToPop();
     }
    public int poll(){
        if(stackPop.empty()&&stackPush.empty()){
            throw new RuntimeException("Your queue is empty.");
        }
        pushToPop();
        return stackPop.pop();
    }
    
    public int peek(){
        if(stackPop.empty()&&stackPush.empty()){
            throw new RuntimeException("Your queue is empty.");
        }
        pushToPop();
        return stackPop.peek();
    }
}
class InputReader{
    BufferedReader buf; // 缓冲字符流
    StringTokenizer tok;

    InputReader(){
        // InputStreamReader inputStreamReader = new InputStreamReader(System.in);
        // buf = new BufferedReader(inputStreamReader);
        buf = new BufferedReader(new InputStreamReader(System.in));
    }

    boolean hasNext(){
        // 为什么用while 而不用if？？ 这里在多线程唤醒那里也遇到了
        while (tok == null || !tok.hasMoreElements()){
            return false;
        }
        return true;
    }
    // 从缓存中读入一行字符串
    void nextLine(){
        try {
            // 创建一个解析给定字符流的tokenizer。
            tok = new StringTokenizer(buf.readLine());
        } catch (Exception e) {
            tok = null;
        }
    }
    String next(){
        if(hasNext()){
            return tok.nextToken();
        }
        return null;
    }
    /*
        数据类型转换
        String --> int，long，double，BigInteger，BigDecimal
     */
    int nextInt(){
        return Integer.parseInt(next());
    }
    long nextLong(){
        return Long.parseLong(next());
    }
    double nextDouble(){
        return Double.parseDouble(next());
    }
    BigInteger nextBigInteger(){
        // 将BigInteger的十进制字符串表示形式转换为BigInteger。
        return new BigInteger(next());
    }
    BigDecimal nextBigDecimal(){
        //将BigDecimal的字符串表示 BigDecimal转换为 BigDecimal 。
        return new BigDecimal(next());
    }
}