简单字符串表达式的计算

最近看了后缀表达式，之前也遇到过类似的面试题，遂写这篇博客，用于以后复用(其中表达式的校验并没有完成)。

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 字符串表达式计算 
 *
 * 2018年2月26日上午11:18:08
 */
public class StringExpressEvaluateUtil {

	/**
	 * 符号优先级集合
	 * 该优先级别用于将中缀表达式转换成后缀表达式过程中使用
	 */
	final static Map<String,Integer> SIGNP_RIORITY =new HashMap<>(); 

	/**
	 * 成对符号集合
	 * 暂时仅用于在将中缀表达式转换成后缀表达式过程中，校验到")"，往前匹配左括号。
	 */
	final static Map<String,Integer> SIGNP_PAIR =new HashMap<>();
	
	private StringExpressEvaluateUtil(){
		//不允许外部进行实例化
	}
	private static StringExpressEvaluateUtil instance;
	
	private static StringExpressEvaluateUtil getInstance(){
		if(instance == null) {
			return new StringExpressEvaluateUtil();
		}else {
			return instance;
		}
	}

	static {

		SIGNP_RIORITY.put("+", 1);
		SIGNP_RIORITY.put("-", 1);
		SIGNP_RIORITY.put("*", 2);
		SIGNP_RIORITY.put("/", 2);
		SIGNP_RIORITY.put("(", -1);
		
		SIGNP_PAIR.put("(",-1);
		SIGNP_PAIR.put(")", 1);
		
	}

	/**
	 * 
	 * @param srcExpress 原始表达式
	 * @return 后缀表达式,用于具体的计算使用
	 * @author riseSun
	
	 * 2018年2月26日上午11:19:59
	 */
	public String transformExpress(String srcExpress) {
		
		if(srcExpress == null) {
			throw new IllegalArgumentException("原始表达式不能为null");
		}

		StringBuilder postfixExpress = new StringBuilder();

		if("".equals(srcExpress.trim())) {
			return postfixExpress.toString();
		}

		//校验原始表达式是否有误
		checkSrcExpress(srcExpress);
		//符号栈 = 中缀->后缀中间产品
		Stack<String> signStack = new Stack<String>();

		/**
		 * 这里为了简单，所以假定原始表达式中，各个字符间具有空格,这样有助于表达式中数据的获取,如下表达式示例中，
		 * 要提取其中的数字30,以及10.2比较麻烦。
		 * 当然，如果没有空格，本人想到使用一下方法：
		 * {假设表达式为：-9+(30-1)*3+10.2/2 }
		 *	将其中的数字，用a、b、c、d、e...代替(记录代替的数字) ，这样可以使用toCharArray()或者split("");获取其中的字符。
		 *  获取到最终后缀表达式之后，将这些字母用原先的数字替换(这个替换过程可以在具体计算表达式的时候再做)
		 */
		for(String c: srcExpress.split(" ")) {
			switch (c) {
				case "+":
				case "-":
				case "*":
				case "/":
					operateSign(c,signStack,postfixExpress);
					break;
				case "(":
					//左括号直接压入到符号栈中
					signStack.push(c);
					break;
				case ")":
					//右括号单独处理
					operateParentheses(c,signStack,postfixExpress);
					break;
				default:
					//除符号外，其他的操作数直接追加到输出中
					postfixExpress.append(" "+c);
					break;
			}
		}
		//最后将符号栈中剩余的符号，追加到输出中
		while(!signStack.isEmpty()) {
			postfixExpress.append(" "+signStack.pop());
		}
		return postfixExpress.toString();
	}
	/**
	 * 校验字符串表达式的正确性
	 * @param srcExpress
	 * @author riseSun
	
	 * 2018年2月26日下午2:55:26
	 */
	public void checkSrcExpress(String srcExpress) {
//		if(false) {
//			throw new IllegalArgumentException("原始表达式存在错误");
//		}
	}
	/**
	 * 处理读取的符号
	 * @param newSign
	 * @param signStack
	 * @param postfixStack
	 * @author riseSun
	
	 * 2018年2月26日下午12:46:38
	 */
	public void operateSign(String newSign,Stack<String> signStack,StringBuilder postfixExpress) {
		//满足空栈或者优先级大于符号栈顶元素的优先级时，将符号直接压入栈中
		if(signStack.isEmpty() || (SIGNP_RIORITY.get(newSign) > SIGNP_RIORITY.get(signStack.peek()))) {
			signStack.push(newSign);
		}else {//出栈，直到栈顶元素优先级<=新符号，或者空栈
			//将符号打印到后缀栈中
			postfixExpress.append(" "+signStack.pop());
			operateSign(newSign, signStack, postfixExpress);
		}
	}
	/**
	 * 处理右括号
	 * 从符号栈中压出元素，并将元素压入到结果栈中，
	 * 直到符号栈中压出相反的符号为止
	 * @param newSign
	 * @param signStack
	 * @param postfixStack
	 * @author riseSun
	 * 2018年2月26日下午12:47:16
	 */
	public void operateParentheses(String newSign,Stack<String> signStack,StringBuilder postfixExpress) {
		while(!signStack.isEmpty() && !isPair(newSign,signStack.peek())) {
			postfixExpress.append(" "+signStack.pop());
		}
		//废弃栈中的左括号
		signStack.pop();
	}
	/**
	 * 判断两个符号是否是对称符号,例如(),[],{}..等
	 * 由SIGNP_PAIR来维护对称关系
	 * @param sign
	 * @param anotherSign
	 * @author riseSun
	
	 * 2018年2月26日下午12:53:30
	 */
	public boolean isPair(String sign,String anotherSign) {
		Integer signInt;
		Integer anotherSignInt;
		return (signInt = SIGNP_PAIR.get(sign)) !=null 
				&& (anotherSignInt = SIGNP_PAIR.get(anotherSign)) !=null 
				&& signInt.intValue()+anotherSignInt.intValue() == 0;
	}

	
	/**
	 * 根据后缀表达式进行计算
	 * @param postfixStack
	 * @return
	 * @author riseSun
	
	 * 2018年2月26日下午2:20:05
	 */
	public static double evaluate(String postfixStack) {

		//用于存放操作数以及中间计算结果
		Stack<String> evaluteStack = new Stack<>();

		String[] source = postfixStack.split(" ");

		for(String s : source) {
			double result;
			switch(s) {
				case "+":
					result = Double.parseDouble(evaluteStack.pop()) + Double.parseDouble(evaluteStack.pop());
					evaluteStack.push(result+"");
					break;
				case "-":
					double meiosis = Double.parseDouble(evaluteStack.pop());//减数
					double minuend = Double.parseDouble(evaluteStack.pop());//被减数
					result = minuend - meiosis;
					evaluteStack.push(result+"");
					break;
				case "*":
					result = Double.parseDouble(evaluteStack.pop()) * Double.parseDouble(evaluteStack.pop());
					evaluteStack.push(result+"");
					break;
				case "/":
					double divisor = Double.parseDouble(evaluteStack.pop());//除数
					double dividend = Double.parseDouble(evaluteStack.pop());//被除数
					result = dividend / divisor; 
					evaluteStack.push(result+"");
					break;
				default:
					//操作数直接压入栈中
					evaluteStack.push(s);
					break;
			}
		}
		//返回最终留在栈中的结果
		return Double.parseDouble(evaluteStack.pop());
	}

	/**
	 * 根据中缀表达式，直接计算结果
	 * @param midExpress
	 * @return
	 * @author riseSun
	
	 * 2018年2月26日下午3:02:28
	 */
	public static double evaluateMidExpress(String midExpress) {
		StringExpressEvaluateUtil instance = getInstance();
		return StringExpressEvaluateUtil.evaluate(instance.transformExpress(midExpress).trim());
	}
	
}