表达式求值 java 修正

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

原帖来自/article/5004656.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();//将栈清空
}
}