devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java 计算字符串表达式（支持个别数学函数，可修改添加）_calexp

作者：小蓝xlanll | 2024-03-26 21:23:36

赞

踩

calexp

1、Calculator

计算入口（calExp方法）

  1. import java.util.Collections;
  2. import java.util.Stack;
  3.  
  4. /**
  5.  *  算数表达式求值
  6.  *  直接调用Calculator的类方法conversion()
  7.  *  传入算数表达式，将返回一个浮点值结果
  8.  *  如果计算过程错误，将返回一个NaN
  9.  */
  10. public class Calculator {
  11.     private Stack<String> postfixStack = new Stack<String>();// 后缀式栈
  12.     private Stack<Character> opStack = new Stack<Character>();// 运算符栈
  13.     private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };// 运用运算符ASCII码-40做索引的运算符优先级
  14.  
  15.     /**
  16.     * <b> 计算字符串式子(计算表达式)
  17.     * </b><br><br><i>Description</i> :
  18.     * @param expression String
  19.     * @return double
  20.     * <br><br>Date: 2020/1/4 13:31     <br>Author : dxl
  21.     */
  22.     public static double calExp(String expression) {
  23.         double result = 0;
  24.         Calculator cal = new Calculator();
  25.         try {
  26.         	//DXL先进行特殊函数运算
  27.         	expression = FunHelper.subCalculate(expression);
  28.             expression = transform(expression);
  29.             result = cal.calculate(expression);
  30.         } catch (Exception e) {
  31.             // e.printStackTrace();
  32.             // 运算错误返回NaN
  33.             return 0.0 / 0.0;
  34.         }
  35.         // return new String().valueOf(result);
  36.         return result;
  37.     }
  38.  
  39.     /**
  40.      * 将表达式中负数的符号更改
  41.      *
  42.      * @param expression
  43.      * 例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
  44.      * @return
  45.      */
  46.     private static String transform(String expression) {
  47.     	
  48.   //DXL   
  49.   //好像是处理最前面负号（最开始做的，忘了）
  50. /
  51.         for (int i = 0; i < expression.length(); i++){
  52.         	if (expression.charAt(i) == '-'){
  53.         		if (i == 0){
  54.         			expression = "0" + expression;
  55.         		}else{
  56.         			char c = expression.charAt(i-1);
  57.         			if (c == '('  ){
  58.         				expression = expression.substring(0, i) + "0" + expression.substring(i, expression.length());
  59.         			}	
  60.         		}
  61.         		
  62.         	}
  63.         }
  64.         	
  65.  
  66.     	   char[] arr = expression.toCharArray();
  67.            for (int i = 0; i < arr.length; i++) {
  68.                if (arr[i] == '-') {
  69.                    if (i == 0) {
  70.                        arr[i] = '~';
  71.                    } else {
  72.                        char c = arr[i - 1];
  73.                        if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
  74.                            arr[i] = '~';
  75.                        }              
  76.     }
  77.             }
  78.         }
  79. //        if(arr[0]=='~'||arr[1]=='('){
  80.         	 if(arr[0]=='~'){
  81.             arr[0]='-';
  82.             return "0"+new String(arr);
  83.         }else{
  84.             return new String(arr);
  85.         }
  86.     }
  87.  
  88.     /**
  89.      * 按照给定的表达式计算
  90.      *
  91.      * @param expression
  92.      * 要计算的表达式例如:5+12*(3+5)/7
  93.      * @return
  94.      */
  95.     public double calculate(String expression) {
  96.         Stack<String> resultStack = new Stack<String>();
  97.         prepare(expression);
  98.         Collections.reverse(postfixStack);// 将后缀式栈反转
  99.         String firstValue, secondValue, currentValue;// 参与计算的第一个值，第二个值和算术运算符
  100.         while (!postfixStack.isEmpty()) {
  101.             currentValue = postfixStack.pop();
  102.             if (!isOperator(currentValue.charAt(0))) {// 如果不是运算符则存入操作数栈中
  103.                 currentValue = currentValue.replace("~", "-");
  104.                 resultStack.push(currentValue);
  105.             } else {// 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
  106.                 secondValue = resultStack.pop();
  107.                 firstValue = resultStack.pop();
  108.  
  109.                 // 将负数标记符改为负号
  110.                 firstValue = firstValue.replace("~", "-");
  111.                 secondValue = secondValue.replace("~", "-");
  112.  
  113.                 String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
  114.                 resultStack.push(tempResult);
  115.             }
  116.         }
  117. //        System.out.println("double��calculate�е�resultStack��"+Double.valueOf(resultStack.pop()));
  118.             return Double.valueOf(resultStack.pop());
  119.     }
  120.  
  121.     /**
  122.      * 数据准备阶段将表达式转换成为后缀式栈
  123.      *
  124.      * @param expression
  125.      */
  126.     private void prepare(String expression) {
  127.         opStack.push(',');// 运算符放入栈底元素逗号，此符号优先级最低
  128.         char[] arr = expression.toCharArray();
  129.         int currentIndex = 0;// 当前字符的位置
  130.         int count = 0;// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
  131.         char currentOp, peekOp;// 当前操作符和栈顶操作符
  132.         for (int i = 0; i < arr.length; i++) {
  133.             currentOp = arr[i];
  134.             if (isOperator(currentOp)) {// 如果当前字符是运算符
  135.                 if (count > 0) {
  136.                     postfixStack.push(new String(arr, currentIndex, count));// 取两个运算符之间的数字
  137.                 }
  138.                 peekOp = opStack.peek();
  139.                 if (currentOp == ')') {// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
  140.                     while (opStack.peek() != '(') {
  141.                         postfixStack.push(String.valueOf(opStack.pop()));
  142.                     }
  143.                     opStack.pop();
  144.                 } else {
  145.                     while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
  146.                         postfixStack.push(String.valueOf(opStack.pop()));
  147.                         peekOp = opStack.peek();
  148.                     }
  149.                     opStack.push(currentOp);
  150.                 }
  151.                 count = 0;
  152.                 currentIndex = i + 1;
  153.             } else {
  154.                 count++;
  155.             }
  156.         }
  157.         if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
  158.             postfixStack.push(new String(arr, currentIndex, count));
  159.         }
  160.  
  161.         while (opStack.peek() != ',') {
  162.             postfixStack.push(String.valueOf(opStack.pop()));// 将操作符栈中的剩余的元素添加到后缀式栈中
  163.         }
  164.     }
  165.  
  166.     /**
  167.      * 判断是否为算术符号
  168.      *
  169.      * @param c
  170.      * @return
  171.      */
  172.     private boolean isOperator(char c) {
  173.         return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
  174.     }
  175.  
  176.     /**
  177.      * 利用ASCII码-40做下标去算术符号优先级
  178.      *
  179.      * @param cur
  180.      * @param peek
  181.      * @return
  182.      */
  183.     public boolean compare(char cur, char peek) {// 如果是peek优先级高于cur，返回true，默认都是peek优先级要低
  184.         boolean result = false;
  185.         if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
  186.             result = true;
  187.         }
  188.         return result;
  189.     }
  190.  
  191.     /**
  192.      * 按照给定的算术运算符做计算
  193.      *
  194.      * @param firstValue
  195.      * @param secondValue
  196.      * @param currentOp
  197.      * @return
  198.      */
  199.     private String calculate(String firstValue, String secondValue, char currentOp) {
  200.         String result = "";
  201.         switch (currentOp) {
  202.         case '+':
  203.             result = String.valueOf(ArithHelper.add(firstValue, secondValue));
  204.             break;
  205.         case '-':
  206.             result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
  207.             break;
  208.         case '*':
  209.             result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
  210.             break;
  211.         case '/':
  212.             result = String.valueOf(ArithHelper.div(firstValue, secondValue));
  213.             break;         
  214.         }
  215.         return result;
  216.     }
  217.     /
  218.     
  219.     public static void main(String[] args) {
  220.    //      	 String expression = "2+3+sin(30+20-20+1-sin(45+45))";
  221. //    	String expression = "2+++++3";
  222. //    	String expression = "sin(0.0/0.0)";
  223. //    	String expression = "arcsin((20)/2/16)";
  224.  	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)";
  225. //    	String expression = "(((sin(20+-10))))";
  226. //    	String expression = "5+(((-(((2+2)))/2)))";
  227. //       	String expression = "5+(-(((2+2)))/2)";
  228. //    	String expression = "5+(-(((2+2)))/2)";
  229. //    	String expression = "5+(-(2+2)/2)";
  230.     	     double result = Calculator.calExp(expression);
  231.     	     System.out.println(expression + " = " + result);
  232.     	     System.out.println();
  233.     	    }
  234.     
  235.     
  236. }

2、ArithHelper

使用java.math.BigDecimal计算double，保证double的计算精度

  1.  
  2. public class ArithHelper {
  3.  
  4.     // 默认除法运算精度
  5.     private static final int DEF_DIV_SCALE = 16;
  6.  
  7.     // 这个类不能实例化
  8.     private ArithHelper() {
  9.     }
  10.  
  11.     /**
  12.      * 提供精确的加法运算。
  13.      *
  14.      * @param v1 被加数
  15.      * @param v2 加数
  16.      * @return 两个参数的和
  17.      */
  18.  
  19.     public static double add(double v1, double v2) {
  20.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  21.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  22.         return b1.add(b2).doubleValue();
  23.     }
  24.  
  25.     public static double add(String v1, String v2) {
  26.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  27.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  28.         return b1.add(b2).doubleValue();
  29.     }
  30.  
  31.     /**
  32.      * 提供精确的减法运算。
  33.      *
  34.      * @param v1 被减数
  35.      * @param v2 减数
  36.      * @return 两个参数的差
  37.      */
  38.  
  39.     public static double sub(double v1, double v2) {
  40.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  41.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  42.         return b1.subtract(b2).doubleValue();
  43.     }
  44.  
  45.     public static double sub(String v1, String v2) {
  46.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  47.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  48.         return b1.subtract(b2).doubleValue();
  49.     }
  50.  
  51.     /**
  52.      * 提供精确的乘法运算。
  53.      *
  54.      * @param v1
  55.      *            被乘数
  56.      * @param v2
  57.      *            乘数
  58.      * @return 两个参数的积
  59.      */
  60.  
  61.     public static double mul(double v1, double v2) {
  62.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  63.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  64.         return b1.multiply(b2).doubleValue();
  65.     }
  66.  
  67.     public static double mul(String v1, String v2) {
  68.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  69.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  70.         return b1.multiply(b2).doubleValue();
  71.     }
  72.  
  73.     /**
  74.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
  75.      *
  76.      * @param v1
  77.      *            被除数
  78.      * @param v2
  79.      *            除数
  80.      * @return 两个参数的商
  81.      */
  82.     public static double div(double v1, double v2) {
  83.         return div(v1, v2, DEF_DIV_SCALE);
  84.     }
  85.  
  86.     public static double div(String v1, String v2) {
  87.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  88.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  89.         return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  90.     }
  91.  
  92.     /**
  93.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
  94.      *
  95.      * @param v1 被除数
  96.      * @param v2 除数
  97.      * @param scale 表示表示需要精确到小数点以后几位。
  98.      * @return 两个参数的商
  99.      */
  100.  
  101.     public static double div(double v1, double v2, int scale) {
  102.         if (scale < 0) {
  103.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  104.         }
  105.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  106.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  107.         return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  108.     }
  109.  
  110.     /**
  111.      * 提供精确的小数位四舍五入处理。
  112.      *
  113.      * @param v 需要四舍五入的数字
  114.      * @param scale 小数点后保留几位
  115.      * @return 四舍五入后的结果
  116.      */
  117.  
  118.     public static double round(double v, int scale) {
  119.         if (scale < 0) {
  120.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  121.         }
  122.         java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
  123.         java.math.BigDecimal one = new java.math.BigDecimal("1");
  124.         return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  125.     }
  126.  
  127.     public static double round(String v, int scale) {
  128.         if (scale < 0) {
  129.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  130.         }
  131.         java.math.BigDecimal b = new java.math.BigDecimal(v);
  132.         java.math.BigDecimal one = new java.math.BigDecimal("1");
  133.         return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  134.     }
  135. }

3、CalHelper

做一些计算前处理，如转换、优先级比较

  1. import java.util.ArrayList;
  2. import java.util.Stack;
  3.  
  4. public class CalHelper {
  5.     /** 
  6.      * 将字符串转化成List 
  7.      * @param str 
  8.      * @return 
  9.      */  
  10.     public ArrayList<String> getStringList(String str){  
  11.         ArrayList<String> result = new ArrayList<String>();  
  12.         String num = "";  
  13.         for (int i = 0; i < str.length(); i++) {  
  14.             if(Character.isDigit(str.charAt(i))){  
  15.                 num = num + str.charAt(i);  
  16.             }else{  
  17.                 if(num != ""){  
  18.                     result.add(num);  
  19.                 }  
  20.                 result.add(str.charAt(i) + "");  
  21.                 num = "";  
  22.             }  
  23.         }  
  24.         if(num != ""){  
  25.             result.add(num);  
  26.         }  
  27.         return result;  
  28.     }  
  29.       
  30.     /** 
  31.      * 将中缀表达式转化为后缀表达式 
  32.      * @param inOrderList 
  33.      * @return 
  34.      */  
  35.     
  36.     //result = [12, +, (, 23, *, 3, -, 56, +, 7, ), *, (, 2, +, 90, ), /, 2]
  37.     public ArrayList<String> getPostOrder(ArrayList<String> inOrderList){  
  38.           
  39.         ArrayList<String> result = new ArrayList<String>();  
  40.         Stack<String> stack = new Stack<String>();  
  41.         for (int i = 0; i < inOrderList.size(); i++) {  
  42.             if(Character.isDigit(inOrderList.get(i).charAt(0))){  
  43.                 result.add(inOrderList.get(i));  
  44.             }else{  
  45.                 switch (inOrderList.get(i).charAt(0)) {  
  46.                 case '(':  
  47.                     stack.push(inOrderList.get(i));  
  48.                     break;  
  49.                 case ')':  
  50.                     while (!stack.peek().equals("(")) {  
  51.                         result.add(stack.pop());  
  52.                     }  
  53.                     stack.pop();  
  54.                     break;  
  55.                 default:  
  56.                     while (!stack.isEmpty() && compare(stack.peek(), inOrderList.get(i))){  
  57.                         result.add(stack.pop());  
  58.                     }  
  59.                     stack.push(inOrderList.get(i));  
  60.                     break;  
  61.                 }  
  62.             }  
  63.         }  
  64.         while(!stack.isEmpty()){  
  65.             result.add(stack.pop());  
  66.         }  
  67.         return result;  
  68.     }  
  69.       
  70.     /** 
  71.      * 计算后缀表达式 
  72.      * @param postOrder 
  73.      * @return 
  74.      */  
  75.     //[12, 23, 3, *, 56, -, 7, +, 2, 90, +, *, 2, /, +]result
  76.     @SuppressWarnings({ "unchecked", "rawtypes" })
  77. 	public Double calculate(ArrayList<String> postOrder){  
  78.         Stack stack = new Stack();  
  79.         for (int i = 0; i < postOrder.size(); i++) {  
  80.             if(Character.isDigit(postOrder.get(i).charAt(0))){  
  81.                 stack.push(Double.parseDouble(postOrder.get(i)));  
  82.             }else{  
  83.             	Double back = (Double)stack.pop();  
  84.             	Double front = (Double)stack.pop();  
  85.             	Double res = 0.0;  
  86.                 switch (postOrder.get(i).charAt(0)) {  
  87.                 case '+':  
  88.                     res = front + back;  
  89.                     break;  
  90.                 case '-':  
  91.                     res = front - back;  
  92.                     break;  
  93.                 case '*':  
  94.                     res = front * back;  
  95.                     break;  
  96.                 case '/':  
  97.                     res = front / back;  
  98.                     break;  
  99.                 }  
  100.                 stack.push(res);  
  101.             }  
  102.         }  
  103.         return (Double)stack.pop();  
  104.     }  
  105.       
  106.     /** 
  107.      * 比较运算符等级 
  108.      * @param peek 
  109.      * @param cur 
  110.      * @return 
  111.      */  
  112.     public static boolean compare(String peek, String cur){  
  113.         if("*".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){  
  114.             return true;  
  115.         }else if("/".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){  
  116.             return true;  
  117.         }else if("+".equals(peek) && ("+".equals(cur) || "-".equals(cur))){  
  118.             return true;  
  119.         }else if("-".equals(peek) && ("+".equals(cur) || "-".equals(cur))){  
  120.             return true;  
  121.         }  
  122.         return false;  
  123.     }  
  124.           
  125. }

4、FunHelper

处理表达式中数学函数的计算，根据需求可在（funCalculate）这里面添加

  1.  
  2. public class FunHelper {
  3.  
  4. 	
  5. 	/**
  6. 	 * 应该是支持函数运算（以前做的，注释忘了）
  7. 	 * @param funname
  8. 	 * @param substring
  9. 	 * @return String substring
  10. 	 */
  11. 	public static String funCalculate (String funname,String substring){
  12. 		double subvalue = Calculator.calExp(substring);
  13. 		if (Double.isNaN(subvalue)){
  14. 			System.out.println("计算"+substring+"出错 :(");
  15. 			substring = "+++";
  16. 			return substring;
  17. 		}
  18.  		
  19. 		switch (funname) {  
  20. 	     case "arcsin":  
  21. 	    	 subvalue = Math.asin(subvalue)*180/Math.PI;  
  22. 	    	 substring = String.valueOf(subvalue);
  23. 	         break;  
  24. 	     case "arccos":  
  25. 	    	 subvalue = Math.acos(subvalue)*180/Math.PI;  
  26. 	    	 substring = String.valueOf(subvalue);
  27. 	         break;
  28. 	     case "arctan":  
  29. 	    	 subvalue = Math.atan(subvalue)*180/Math.PI;  
  30. 	             break;
  31. 	     case "sin":  
  32. 	    	 subvalue = Math.sin(Math.PI*subvalue/180);  
  33. 	    	 substring = String.valueOf(subvalue);
  34. 	             break;
  35. 	     case "cos":  
  36. 	    	 subvalue = Math.cos(Math.PI*subvalue/180);  
  37. 	    	 substring = String.valueOf(subvalue);
  38. 	             break;
  39. 	     case "tan":  
  40. 	    	 subvalue = Math.tan(Math.PI*subvalue/180); 
  41. 	    	 substring = String.valueOf(subvalue);
  42. 	             break;
  43. 	     default : System.out.println("不支持"+funname+"() :(");
  44. 	     substring = "+++";
  45. 	             break;
  46. 	     }  
  47. 		 return substring;
  48. 	 }
  49. 	///
  50. 	
  51. 	public static String subCalculate(String expression){   	
  52. 	   for (int i = 0; i < expression.length(); i++) { 
  53. 		   char temchar1 = expression.charAt(i);
  54. 		   Integer tem1 = Integer.valueOf(temchar1);
  55. 	        if(tem1 >96 && tem1 < 123 && tem1 != 101){
  56. 	       	 	int indexleft = i;
  57. 	       	 	int indexright = i;
  58. 	       	 	int p = 0;
  59. 	       	 	for (int j = i;j < expression.length(); j++){
  60. 	           	 
  61. 	       	 		if (expression.charAt(j) == '(' ){
  62. 	           		 indexleft = j;
  63. 	           		 break;
  64. 	       	 		}
  65. 	       	 	}
  66. 	       	 	for (int t = indexleft+1;t < expression.length(); t++){
  67. 	           	 
  68. 	       	 		if (expression.charAt(t) == '('){
  69. 	           		 p++;
  70. 	       	 		}else{
  71. 	       	 			if (expression.charAt(t) == ')'){
  72. 	           			 p--;
  73. 	       	 			}
  74. 	       	 		}
  75. 	       	 		if (p == -1){
  76. 	           			indexright = t;
  77. 	           			 break;
  78. 	           		 }
  79. 	       	 	}
  80. 	           		String substring =  expression.substring(indexleft+1, indexright);
  81. 	           		String subvalue = FunHelper.funCalculate(expression.substring(i, indexleft),substring);
  82. 	           		String funstring = expression.substring(i, indexright+1);
  83. 	           		expression =  expression.replace(funstring,subvalue);
  84. 	       	 	}
  85. 	        }
  86. 	   return expression;
  87. 	}
  88.  
  89. }
PS：很早指点优化的，现在重新发布下，自行修改
 
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/319781
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号