逆波兰法（计算器）程序<无括号版>

涉及队列、栈的运用。

Java中队列可以用：

Queue<String> q = new LinkedList();

来声明，其主要的方法有：

poll(),peak(),offer(),clear(),size()等。

Java中栈可以用:

Stack s = new Stack();

来声明，其主要方法有：
push(),peak(),pop(),clear(),size()等。

 package preTest;

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

 //逆波兰表示法
 public class nbl {
     public static Stack sigStack = new Stack();
     public static Queue<String> nblQueue = new LinkedList();
     public static Stack numFromQueue = new Stack();
     public static void main(String[] args) {
         Scanner in=new Scanner(System.in);
         while(in.hasNext()){
             String str = in.nextLine();
             int result = cal(str);
             System.out.println(result);
         }
     }

     public static int cal(String str){
         sigStack.clear();
         nblQueue.clear();
         StringBuilder sb = new StringBuilder();
         int len = str.length();
         int result= 0;
         //压栈和入队操作
         for(int i=0; i<len;i++){
             char c = str.charAt(i);
             if(c>='0' && c <='9'){
                 sb.append(c);
                 if(i==len-1){
                     nblQueue.offer(sb.toString());
                 }
             }else{
                 nblQueue.offer(sb.toString());
                 sb.replace(0, sb.length(), "");
                 if(sigStack.size() == 0){
                     sigStack.push(c);
                 }else{
                     char existed = (char)sigStack.peek();
                     //如果已经压栈的符号优先级>=当前符号c，则完成压栈符号的操作
                     if(c=='+' || c=='-'){
                         zhengli();
                         sigStack.push(c);
                         //当两个都是乘除运算时
                     }else if(existed =='*' || existed == '/'){
                         tinyAdjust(c);
                     }else{//新符号乘除，旧符号加减
                         sigStack.push(c);
                     }
                 }
             }
         }
         zhengli();
         //出队操作
         numFromQueue.clear();
         result = releaseQueue();
         return result;
     }

     public static void zhengli(){
         while(sigStack.size() > 0){
             char c = (char)sigStack.pop();
             nblQueue.offer(new StringBuilder().append(c).toString());
         }
     }

     public static void tinyAdjust(char c){
         char ch = (char)sigStack.pop();
         nblQueue.offer(new StringBuilder().append(ch).toString());
         sigStack.push(c);
     }

     public static int releaseQueue(){
         int len = nblQueue.size();
         boolean isNum = false;
         for(int i=0; i<len; i++){
             isNum = judge();
             if(isNum){
                 int num = Integer.parseInt(nblQueue.poll());
                 numFromQueue.push(num);
             }else{
                 int a = (int)numFromQueue.pop();
                 int b = (int)numFromQueue.pop();
                 char c = nblQueue.poll().charAt(0);
                 int res = compute(b,a,c);
                 numFromQueue.push(res);
             }
         }
         return (int)numFromQueue.pop();
     }

     public static boolean judge(){
         String str = nblQueue.peek();
         char c = str.charAt(0);
         if(c>='0' && c<='9'){
             return true;
         }else{
             return false;
         }
     }

     //简单加减乘除计算
         public static int compute(int a, int b, char c){
             int result = 0;
             switch(c){
             case '+': result = a+b;
                 break;
             case '-': result = a-b;
                 break;
             case '*': result = a*b;
                 break;
             case '/': result = a/b;
                 break;
             }
             return result;
         }

 }