四则运算表达式解析

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

public class Main {

public static String str = "";
//(1+(4-2)*3)-2*3+1
//(1+(4-2)*3)*(2+3)+1
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
str = scan.nextLine();
scan.close();
System.out.println("pattern:" + str);
dealKH();
while(str.indexOf('*') != -1 || str.indexOf('/') != -1 || str.indexOf('+') != -1 || str.indexOf('-') != -1){
calcPattern(str);
}
System.out.println("===================================");
System.out.println("result:"+str);
}

private static void dealKH() {
Stack<Integer> stack = new Stack<Integer>();
String tempStr = str;
for (int i = 0; i < tempStr.length(); i++) {
char c = tempStr.charAt(i);
if (c == '(') {
stack.push(i);
} else if (c == ')') {
if (!stack.isEmpty()) {
int pos = stack.pop();
String pat = tempStr.substring(pos + 1, i);
//					System.out.println("calc Pattern:"+pat);
calcPattern(pat);
//					System.out.println("calc before:"+str);
str = str.replace("("+pat+")", pat);
//					System.out.println("calc after:"+str);
System.out.println("next term:" + str);
if(str.indexOf('(')!=-1){
dealKH();
break;
}
}
}
}
}

private static void calcPattern(String pat) {
List<String> list = splitStr(pat);
String[] pmOpt = new String[]{"*","/"};
String[] ccOpt = new String[]{"+","-",};
if(pat.indexOf('*') != -1 || pat.indexOf('/') != -1){
executeCalc(pmOpt,list,pat);
}else if(pat.indexOf('+') != -1 || pat.indexOf('-') != -1){
executeCalc(ccOpt,list,pat);
}
}

private static List<String> splitStr(String pat) {
List<String> list = new ArrayList<>();
list.add("");
String tempStr = pat;
for (int i = 0; i < tempStr.length(); i++) {
char c = tempStr.charAt(i);
if(c=='*' || c=='/' || c=='+' || c=='-'){
list.add(c+"");
list.add("");
}else{
String s = list.get(list.size()-1);
list.remove(list.size()-1);
list.add(s+""+c);
}
}
return list;
}

private static void executeCalc(String[] pmOpt,List<String> list, String pat){
Integer tindex = null;
for (String opt : pmOpt) {
int index = list.indexOf(opt);
tindex = tindex==null||tindex==-1?index:(tindex>index&&index!=-1?index:tindex);
}
if(tindex==null || tindex==-1)
return;
int result = calc(list.get(tindex-1)+list.get(tindex)+list.get(tindex+1));
str = str.replace(list.get(tindex-1)+list.get(tindex)+list.get(tindex+1),result+"");
pat = pat.replace(list.get(tindex-1)+list.get(tindex)+list.get(tindex+1),result+"");
System.out.println("next term calc["+pat+"]:" + str);
for (String opt : pmOpt) {
if(pat.indexOf(opt)!=-1){
list = splitStr(pat);
executeCalc(pmOpt,list,pat);
}
}
}

private static int calc(String pattern) {
int result = 0;
if (pattern.indexOf('*') != -1) {
result = Integer.parseInt(pattern.split("\\*")[0]) * Integer.parseInt(pattern.split("\\*")[1]);
} else if (pattern.indexOf('/') != -1) {
result = Integer.parseInt(pattern.split("/")[0]) / Integer.parseInt(pattern.split("/")[1]);
} else if (pattern.indexOf('+') != -1) {
result = Integer.parseInt(pattern.split("\\+")[0]) + Integer.parseInt(pattern.split("\\+")[1]);
} else if (pattern.indexOf('-') != -1) {
result = Integer.parseInt(pattern.split("-")[0]) - Integer.parseInt(pattern.split("-")[1]);
}
return result;
}

}

(1+(4-2)*3)*(2+3)+1
pattern:(1+(4-2)*3)*(2+3)+1
next term calc[2]:(1+(2)*3)*(2+3)+1
next term:(1+(2)*3)*(2+3)+1
next term:(1+2*3)*(2+3)+1
next term calc[1+6]:(1+6)*(2+3)+1
next term:(1+6)*(2+3)+1
next term calc[7]:(7)*(2+3)+1
next term:(7)*(2+3)+1
next term:7*(2+3)+1
next term calc[5]:7*(5)+1
next term:7*(5)+1
next term:7*5+1
next term calc[35+1]:35+1
next term calc[36]:36
===================================
result:36