表达式求值 java 修正

解题思想：将原表达式转换成后缀表达式，然后再对后缀表达式进行处理即可。本代码借鉴网上的资源进行了优化和部分的修改，使用者可以加上一些其他的异常处理

原帖来自http://www.cnblogs.com/yinger/archive/2011/07/01/2095500.html,在判断数字和处理空格上做了一些改进,原版只能计算多只两位数,使用while循环改进

解题思想：将原表达式转换成后缀表达式，然后再对后缀表达式进行处理即可。本代码借鉴网上的资源进行了优化和部分的修改，使用者可以加上一些其他的异常处理
--------------------------主方法（main）部分--------------------------
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author Hanson
 *
 */
public class MainWork {

    /**
     * 获取用户输入
     * @param args
     */
     
   public static void main(String arg[]) {
       System.out.println("请输入合法的表达式,操作数是整数");
       Scanner stringScannner=new Scanner(System.in);
       String expression=stringScannner.nextLine(); 
       ArrayList postfix = ExpressionEvaluation.transform(trimEmpty(expression));
       System.out.println(expression);//将原表达式打印
       System.out.println("后缀表达式: "+postfix);//将中缀表达式打印
       ExpressionEvaluation.calculate(postfix);
   }
   
 
   /**
    * 将字符串里的空格清理掉
    * @param expression 要处理的字符串
    */
   static String trimEmpty(String expression){
      return expression.replace(" ","");
   }
}

--------------------------表达式处理部分--------------------------
/**
 * 
 */
import java.util.*;

/**
 * 处理表达式并输出结果
 * @author Hanson
 */
public class ExpressionEvaluation{      
    /**
     * 将中缀表达式转换成后缀表达式
     * @param prefix 前缀表达式
     */
    public static ArrayList transform(String prefix) {
        int i, len = prefix.length();// 用字符数组保存前缀表达式
        prefix=prefix+ '#';// 让前缀表达式以'#'结尾
        Stack<Character> stack = new Stack<Character>();// 保存操作符的栈
        Stack<Integer> intStack = new Stack<Integer>();// 保存操作数的栈，要保证顶部元素是要加入中缀的操作数
        stack.push('#');// 首先让'#'入栈
        ArrayList postfix = new ArrayList();
        // 保存后缀表达式的列表,可能是数字，也可能是操作符，之前使用的是ArrayList
        for (i = 0; i < len + 1; i++) {
            int digit=0;
            while(Character.isDigit(prefix.charAt(i))){
                digit=digit*10+(prefix.charAt(i)-'0');
                if(intStack.isEmpty()){
                    intStack.push(digit);
                }
                else{
                    intStack.pop();//如果栈内已有元素，则先弹出，然后将新的元素加入
                    intStack.push(digit);
                }
                i++;
            }
            if(!intStack.isEmpty()){
                postfix.add(intStack.pop());//如果当前栈不为空，则将栈内的元素加到中缀字符串中，然后将元素弹出
            }
            if (!Character.isDigit(prefix.charAt(i))) {// 当前字符是一个操作符
                switch (prefix.charAt(i)) {
                case '(':
                    stack.push(prefix.charAt(i));// 开括号只是放入到栈中，不放入到后缀表达式中
                    break;
                case ')':
                    while (stack.peek() != '(') {
                        postfix.add(stack.pop());// 闭括号是不入栈的
                    }
                    stack.pop();
                    break;
                default:// 默认:+ - * /
                    while ((stack.peek() != '#')&& compare(stack.peek(), prefix.charAt(i))) {
                        postfix.add(stack.pop());// 不断弹栈，直到当前的操作符的优先级高于栈顶操作符
                    }
                    if (prefix.charAt(i) != '#') {// 如果当前的操作符不是'#'(结束符)，那么入操作符栈
                        stack.push(prefix.charAt(i));// 最后的标识符'#'是不入栈的
                    }
                    break;
                }
            }
        }
        return postfix;
    }

    /**
     * 比较运算符之间的优先级
     * @param peek,cur两个操作符
     * @return  如果是peek优先级高于cur，返回true，否则返回false
     */
    public static boolean compare(char peek, char cur) {
        if (peek == '*'
                && (cur == '+' || cur == '-' || cur == '/' || cur == '*')) {// 如果cur是'('，那么cur的优先级高,如果是')'，是在上面处理
            return true;
        } else if (peek == '/'
                && (cur == '+' || cur == '-' || cur == '*' || cur == '/')) {
            return true;
        } else if (peek == '+' && (cur == '+' || cur == '-')) {
            return true;
        } else if (peek == '-' && (cur == '+' || cur == '-')) {
            return true;
        } else if (cur == '#') {// 这个很特别，这里说明到了中缀表达式的结尾，那么就要弹出操作符栈中的所有操作符到后缀表达式中
            return true;// 当cur为'#'时，cur的优先级算是最低的
        }
        return false;// 开括号是不用考虑的，它的优先级一定是最小的,cur一定是入栈
    }
    
    /**
     * 计算后缀表达式
     * @param postfix 表达式经过处理后得到的后缀表达式
     */
    public static void calculate(ArrayList postfix){//后缀表达式的运算顺序就是操作符出现的先后顺序
        int i,res=0,size=postfix.size();
        Stack<Integer> stack_num=new Stack<Integer>();
        for(i=0;i<size;i++){
            if(postfix.get(i).getClass()==Integer.class){//如果是操作数
                stack_num.push((Integer)postfix.get(i));
            }else{//如果是操作符
                int a=stack_num.pop();
                int b=stack_num.pop();//注意运算时的前者和后者
                switch((Character)postfix.get(i)){//适配不同的操作符
                case '+':
                    res=b+a;
                    break;
                case '-':
                    res=b-a;
                    break;
                case '*':
                    res=b*a;
                    break;
                case '/':
                    res=b/a;
                    break;
                }
                stack_num.push(res);
            }
        }
        System.out.println("res "+" "+stack_num.peek());
        stack_num.clear();//将栈清空
    }
}