java 計算字符串表達式（支持個別數學函數，可修改添加）

1、Calculator

計算入口（calExp方法）

import java.util.Collections;
import java.util.Stack;

/**
 *  算數表達式求值
 *  直接調用Calculator的類方法conversion()
 *  傳入算數表達式，將返回一個浮點值結果
 *  如果計算過程錯誤，將返回一個NaN
 */
public class Calculator {
    private Stack<String> postfixStack = new Stack<String>();// 後綴式棧
    private Stack<Character> opStack = new Stack<Character>();// 運算符棧
    private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };// 運用運算符ASCII碼-40做索引的運算符優先級

    /**
    * <b> 計算字符串式子(計算表達式)
    * </b><br><br><i>Description</i> :
    * @param expression String
    * @return double
    * <br><br>Date: 2020/1/4 13:31     <br>Author : dxl
    */
    public static double calExp(String expression) {
        double result = 0;
        Calculator cal = new Calculator();
        try {
        	//DXL先進行特殊函數運算
        	expression = FunHelper.subCalculate(expression);
            expression = transform(expression);
            result = cal.calculate(expression);
        } catch (Exception e) {
            // e.printStackTrace();
            // 運算錯誤返回NaN
            return 0.0 / 0.0;
        }
        // return new String().valueOf(result);
        return result;
    }

    /**
     * 將表達式中負數的符號更改
     *
     * @param expression
     * 例如-2+-1*(-3E-2)-(-1) 被轉爲 ~2+~1*(~3E~2)-(~1)
     * @return
     */
    private static String transform(String expression) {
    	
  //DXL   
  //好像是處理最前面負號（最開始做的，忘了）
/////////////////////////////////////////////////////////////////////////////////////////////////////////
        for (int i = 0; i < expression.length(); i++){
        	if (expression.charAt(i) == '-'){
        		if (i == 0){
        			expression = "0" + expression;
        		}else{
        			char c = expression.charAt(i-1);
        			if (c == '('  ){
        				expression = expression.substring(0, i) + "0" + expression.substring(i, expression.length());
        			}	
        		}
        		
        	}
        }
        	
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
    	   char[] arr = expression.toCharArray();
           for (int i = 0; i < arr.length; i++) {
               if (arr[i] == '-') {
                   if (i == 0) {
                       arr[i] = '~';
                   } else {
                       char c = arr[i - 1];
                       if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
                           arr[i] = '~';
                       }              
    }
            }
        }
//        if(arr[0]=='~'||arr[1]=='('){
        	 if(arr[0]=='~'){
            arr[0]='-';
            return "0"+new String(arr);
        }else{
            return new String(arr);
        }
    }

    /**
     * 按照給定的表達式計算
     *
     * @param expression
     * 要計算的表達式例如:5+12*(3+5)/7
     * @return
     */
    public double calculate(String expression) {
        Stack<String> resultStack = new Stack<String>();
        prepare(expression);
        Collections.reverse(postfixStack);// 將後綴式棧反轉
        String firstValue, secondValue, currentValue;// 參與計算的第一個值，第二個值和算術運算符
        while (!postfixStack.isEmpty()) {
            currentValue = postfixStack.pop();
            if (!isOperator(currentValue.charAt(0))) {// 如果不是運算符則存入操作數棧中
                currentValue = currentValue.replace("~", "-");
                resultStack.push(currentValue);
            } else {// 如果是運算符則從操作數棧中取兩個值和該數值一起參與運算
                secondValue = resultStack.pop();
                firstValue = resultStack.pop();

                // 將負數標記符改爲負號
                firstValue = firstValue.replace("~", "-");
                secondValue = secondValue.replace("~", "-");

                String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
                resultStack.push(tempResult);
            }
        }
//        System.out.println("double��calculate�е�resultStack��"+Double.valueOf(resultStack.pop()));
            return Double.valueOf(resultStack.pop());
    }

    /**
     * 數據準備階段將表達式轉換成爲後綴式棧
     *
     * @param expression
     */
    private void prepare(String expression) {
        opStack.push(',');// 運算符放入棧底元素逗號，此符號優先級最低
        char[] arr = expression.toCharArray();
        int currentIndex = 0;// 當前字符的位置
        int count = 0;// 上次算術運算符到本次算術運算符的字符的長度便於或者之間的數值
        char currentOp, peekOp;// 當前操作符和棧頂操作符
        for (int i = 0; i < arr.length; i++) {
            currentOp = arr[i];
            if (isOperator(currentOp)) {// 如果當前字符是運算符
                if (count > 0) {
                    postfixStack.push(new String(arr, currentIndex, count));// 取兩個運算符之間的數字
                }
                peekOp = opStack.peek();
                if (currentOp == ')') {// 遇到反括號則將運算符棧中的元素移除到後綴式棧中直到遇到左括號
                    while (opStack.peek() != '(') {
                        postfixStack.push(String.valueOf(opStack.pop()));
                    }
                    opStack.pop();
                } else {
                    while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
                        postfixStack.push(String.valueOf(opStack.pop()));
                        peekOp = opStack.peek();
                    }
                    opStack.push(currentOp);
                }
                count = 0;
                currentIndex = i + 1;
            } else {
                count++;
            }
        }
        if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {// 最後一個字符不是括號或者其他運算符的則加入後綴式棧中
            postfixStack.push(new String(arr, currentIndex, count));
        }

        while (opStack.peek() != ',') {
            postfixStack.push(String.valueOf(opStack.pop()));// 將操作符棧中的剩餘的元素添加到後綴式棧中
        }
    }

    /**
     * 判斷是否爲算術符號
     *
     * @param c
     * @return
     */
    private boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
    }

    /**
     * 利用ASCII碼-40做下標去算術符號優先級
     *
     * @param cur
     * @param peek
     * @return
     */
    public boolean compare(char cur, char peek) {// 如果是peek優先級高於cur，返回true，默認都是peek優先級要低
        boolean result = false;
        if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
            result = true;
        }
        return result;
    }

    /**
     * 按照給定的算術運算符做計算
     *
     * @param firstValue
     * @param secondValue
     * @param currentOp
     * @return
     */
    private String calculate(String firstValue, String secondValue, char currentOp) {
        String result = "";
        switch (currentOp) {
        case '+':
            result = String.valueOf(ArithHelper.add(firstValue, secondValue));
            break;
        case '-':
            result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
            break;
        case '*':
            result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
            break;
        case '/':
            result = String.valueOf(ArithHelper.div(firstValue, secondValue));
            break;         
        }
        return result;
    }
    /////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////
    public static void main(String[] args) {
   //      	 String expression = "2+3+sin(30+20-20+1-sin(45+45))";
//    	String expression = "2+++++3";
//    	String expression = "sin(0.0/0.0)";
//    	String expression = "arcsin((20)/2/16)";
 	String expression = "2+3+sin(13-tan(90/2)+sin(44+cos(50-20-30)+60-30/2))+tan(45)+2e1*arcsin(1/2.5)";
//    	String expression = "(((sin(20+-10))))";
//    	String expression = "5+(((-(((2+2)))/2)))";
//       	String expression = "5+(-(((2+2)))/2)";
//    	String expression = "5+(-(((2+2)))/2)";
//    	String expression = "5+(-(2+2)/2)";
    	     double result = Calculator.calExp(expression);
    	     System.out.println(expression + " = " + result);
    	     System.out.println();
    	    }
    
    
}

2、ArithHelper

使用java.math.BigDecimal計算double，保證double的計算精度

public class ArithHelper {

    // 默認除法運算精度
    private static final int DEF_DIV_SCALE = 16;

    // 這個類不能實例化
    private ArithHelper() {
    }

    /**
     * 提供精確的加法運算。
     *
     * @param v1 被加數
     * @param v2 加數
     * @return 兩個參數的和
     */

    public static double add(double v1, double v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
        java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    public static double add(String v1, String v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
        java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精確的減法運算。
     *
     * @param v1 被減數
     * @param v2 減數
     * @return 兩個參數的差
     */

    public static double sub(double v1, double v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
        java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    public static double sub(String v1, String v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
        java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精確的乘法運算。
     *
     * @param v1
     *            被乘數
     * @param v2
     *            乘數
     * @return 兩個參數的積
     */

    public static double mul(double v1, double v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
        java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    public static double mul(String v1, String v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
        java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到 小數點以後10位，以後的數字四捨五入。
     *
     * @param v1
     *            被除數
     * @param v2
     *            除數
     * @return 兩個參數的商
     */
    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    public static double div(String v1, String v2) {
        java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
        java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
        return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供（相對）精確的除法運算。當發生除不盡的情況時，由scale參數指 定精度，以後的數字四捨五入。
     *
     * @param v1 被除數
     * @param v2 除數
     * @param scale 表示表示需要精確到小數點以後幾位。
     * @return 兩個參數的商
     */

    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
        }
        java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
        java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精確的小數位四捨五入處理。
     *
     * @param v 需要四捨五入的數字
     * @param scale 小數點後保留幾位
     * @return 四捨五入後的結果
     */

    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
        }
        java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
        java.math.BigDecimal one = new java.math.BigDecimal("1");
        return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    public static double round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
        }
        java.math.BigDecimal b = new java.math.BigDecimal(v);
        java.math.BigDecimal one = new java.math.BigDecimal("1");
        return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

3、CalHelper

做一些計算前處理，如轉換、優先級比較

import java.util.ArrayList;
import java.util.Stack;

public class CalHelper {
    /** 
     * 將字符串轉化成List 
     * @param str 
     * @return 
     */  
    public ArrayList<String> getStringList(String str){  
        ArrayList<String> result = new ArrayList<String>();  
        String num = "";  
        for (int i = 0; i < str.length(); i++) {  
            if(Character.isDigit(str.charAt(i))){  
                num = num + str.charAt(i);  
            }else{  
                if(num != ""){  
                    result.add(num);  
                }  
                result.add(str.charAt(i) + "");  
                num = "";  
            }  
        }  
        if(num != ""){  
            result.add(num);  
        }  
        return result;  
    }  
      
    /** 
     * 將中綴表達式轉化爲後綴表達式 
     * @param inOrderList 
     * @return 
     */  
    
    //result = [12, +, (, 23, *, 3, -, 56, +, 7, ), *, (, 2, +, 90, ), /, 2]
    public ArrayList<String> getPostOrder(ArrayList<String> inOrderList){  
          
        ArrayList<String> result = new ArrayList<String>();  
        Stack<String> stack = new Stack<String>();  
        for (int i = 0; i < inOrderList.size(); i++) {  
            if(Character.isDigit(inOrderList.get(i).charAt(0))){  
                result.add(inOrderList.get(i));  
            }else{  
                switch (inOrderList.get(i).charAt(0)) {  
                case '(':  
                    stack.push(inOrderList.get(i));  
                    break;  
                case ')':  
                    while (!stack.peek().equals("(")) {  
                        result.add(stack.pop());  
                    }  
                    stack.pop();  
                    break;  
                default:  
                    while (!stack.isEmpty() && compare(stack.peek(), inOrderList.get(i))){  
                        result.add(stack.pop());  
                    }  
                    stack.push(inOrderList.get(i));  
                    break;  
                }  
            }  
        }  
        while(!stack.isEmpty()){  
            result.add(stack.pop());  
        }  
        return result;  
    }  
      
    /** 
     * 計算後綴表達式 
     * @param postOrder 
     * @return 
     */  
    //[12, 23, 3, *, 56, -, 7, +, 2, 90, +, *, 2, /, +]result
    @SuppressWarnings({ "unchecked", "rawtypes" })
	public Double calculate(ArrayList<String> postOrder){  
        Stack stack = new Stack();  
        for (int i = 0; i < postOrder.size(); i++) {  
            if(Character.isDigit(postOrder.get(i).charAt(0))){  
                stack.push(Double.parseDouble(postOrder.get(i)));  
            }else{  
            	Double back = (Double)stack.pop();  
            	Double front = (Double)stack.pop();  
            	Double res = 0.0;  
                switch (postOrder.get(i).charAt(0)) {  
                case '+':  
                    res = front + back;  
                    break;  
                case '-':  
                    res = front - back;  
                    break;  
                case '*':  
                    res = front * back;  
                    break;  
                case '/':  
                    res = front / back;  
                    break;  
                }  
                stack.push(res);  
            }  
        }  
        return (Double)stack.pop();  
    }  
      
    /** 
     * 比較運算符等級 
     * @param peek 
     * @param cur 
     * @return 
     */  
    public static boolean compare(String peek, String cur){  
        if("*".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){  
            return true;  
        }else if("/".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){  
            return true;  
        }else if("+".equals(peek) && ("+".equals(cur) || "-".equals(cur))){  
            return true;  
        }else if("-".equals(peek) && ("+".equals(cur) || "-".equals(cur))){  
            return true;  
        }  
        return false;  
    }  
          
}

4、FunHelper

處理表達式中數學函數的計算，根據需求可在（funCalculate）這裏面添加

public class FunHelper {
 
	////////////////////////////////////////
	/**
	 * 應該是支持函數運算（以前做的，註釋忘了）
	 * @param funname
	 * @param substring
	 * @return String substring
	 */
	public static String funCalculate (String funname,String substring){
		double subvalue = Calculator.calExp(substring);
		if (Double.isNaN(subvalue)){
			System.out.println("計算"+substring+"出錯 :(");
			substring = "+++";
			return substring;
		}
 		
		switch (funname) {  
	     case "arcsin":  
	    	 subvalue = Math.asin(subvalue)*180/Math.PI;  
	    	 substring = String.valueOf(subvalue);
	         break;  
	     case "arccos":  
	    	 subvalue = Math.acos(subvalue)*180/Math.PI;  
	    	 substring = String.valueOf(subvalue);
	         break;
	     case "arctan":  
	    	 subvalue = Math.atan(subvalue)*180/Math.PI;  
	             break;
	     case "sin":  
	    	 subvalue = Math.sin(Math.PI*subvalue/180);  
	    	 substring = String.valueOf(subvalue);
	             break;
	     case "cos":  
	    	 subvalue = Math.cos(Math.PI*subvalue/180);  
	    	 substring = String.valueOf(subvalue);
	             break;
	     case "tan":  
	    	 subvalue = Math.tan(Math.PI*subvalue/180); 
	    	 substring = String.valueOf(subvalue);
	             break;
	     default : System.out.println("不支持"+funname+"() :(");
	     substring = "+++";
	             break;
	     }  
		 return substring;
	 }
	///////////////////////////////////////////
	
	public static String subCalculate(String expression){   	
	   for (int i = 0; i < expression.length(); i++) { 
		   char temchar1 = expression.charAt(i);
		   Integer tem1 = Integer.valueOf(temchar1);
	        if(tem1 >96 && tem1 < 123 && tem1 != 101){
	       	 	int indexleft = i;
	       	 	int indexright = i;
	       	 	int p = 0;
	       	 	for (int j = i;j < expression.length(); j++){
	           	 
	       	 		if (expression.charAt(j) == '(' ){
	           		 indexleft = j;
	           		 break;
	       	 		}
	       	 	}
	       	 	for (int t = indexleft+1;t < expression.length(); t++){
	           	 
	       	 		if (expression.charAt(t) == '('){
	           		 p++;
	       	 		}else{
	       	 			if (expression.charAt(t) == ')'){
	           			 p--;
	       	 			}
	       	 		}
	       	 		if (p == -1){
	           			indexright = t;
	           			 break;
	           		 }
	       	 	}
	           		String substring =  expression.substring(indexleft+1, indexright);
	           		String subvalue = FunHelper.funCalculate(expression.substring(i, indexleft),substring);
	           		String funstring = expression.substring(i, indexright+1);
	           		expression =  expression.replace(funstring,subvalue);
	       	 	}
	        }
	   return expression;
	}

}

PS：很早指點優化的，現在重新發佈下，自行修改