四则运算表达式解析

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