字符串公式计算，包含常用数学公式，java实现

已于 2022-10-25 20:54:56 修改
阅读量3.4k 收藏 5
点赞数
分类专栏： java 文章标签： java 前端 算法
于 2022-10-20 17:53:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48356746/article/details/127432031
版权

业务需要，做一个用户自定义的公式计算。

公式由前端自定义，生成字符串发给后端，由后端完成计算。

公式需要支持四则运算，支持常用函数，支持函数的嵌套运算。

字符串类似这种

“1-2.5+SUM(3*4,5,SUM(IF(“皮卡”=“皮卡丘”,5,DAYS(“2022-10-19”,“2022-10-29”)),6))”

字符串四则运算，首先下意识就想到后缀表达式，思路就是基于后缀表达式添加函数的兼容。

中缀转后缀之前，首先把字符串分割成列表，这里规定函数中用到字符串为参数，比如日期，字符串，需要用""包起来。

/**
 * 将表达式转为list
 */
private static List<String> expressionToList(String text) {
    int index = 0;
    List<String> list = new ArrayList<>();
    try {
        String opStr = replaceFunctionStr(text);
        do {
            char ch = opStr.charAt(index);
            if (ch < 48 || ch > 57) {
                if (ch == '"') {
                    //是字符参数,截取到下一个引号为止
                    String str = "";
                    index += 1;
                    while (index < opStr.length() && opStr.charAt(index) != '"') {
                        str += opStr.charAt(index);
                        index++;
                    }
                    list.add(str);
                    index++;
                } else {
                    //是操作符，判断多位操作符的情况 例如不等，大于等于
                    if (ch == '>' || ch == '<') {
                        String str = "";
                        while (index < opStr.length() && ((opStr.charAt(index) < 48 || opStr.charAt(index) > 57) && '(' != opStr.charAt(index) && '"' != opStr
                                .charAt(index))) {
                            str += opStr.charAt(index);
                            index++;
                        }
                        list.add(str);
                    } else {
                        //是操作符，直接添加至list中
                        index++;
                        list.add(ch + "");
                    }
                }
            } else if (ch >= 48 && ch <= 57) {
                //是数字,判断多位数的情况
                String str = "";
                while (index < opStr.length() && ((opStr.charAt(index) >= 48 && opStr.charAt(index) <= 57) || '.' == opStr.charAt(index))) {
                    str += opStr.charAt(index);
                    index++;
                }
                list.add(str);
            }
        } while (index < opStr.length());
    } catch (Throwable e) {
        throw new EqException(EqErrorEnum.E_01);
    }
    return list;
}

执行结果：

*[1, -, 2.5, +, S, (, 3, , 4, , 5, , S, (, I, (, 皮卡, =, 皮卡丘, , 5, , D, (, 2022-10-19, , 2022-10-29, ), ), , 6, ), )]

再将中缀表达式List转为后缀表达式List

/**
 * 中缀转后缀
 */
private static List<String> parseToSuffixExpression(List<String> expressionList) {
    Stack<String> opStack = new Stack<>();
    List<String> suffixList = new ArrayList<>();
    for (String item : expressionList) {
        if (isOperator(item)) {
            //是操作符 判断操作符栈是否为空
            if (opStack.isEmpty() || "(".equals(opStack.peek()) || priority(item) > priority(opStack.peek()) || ",".equals(opStack.peek())) {
                //为空或者栈顶元素为左括号或者当前操作符大于栈顶操作符直接压栈
                opStack.push(item);
            } else if (",".equals(item)) {
                //参数间隔符，说明聚合公式还没结束
                if (isOperator(opStack.peek())) {
                    suffixList.add(opStack.pop());
                    opStack.push(item);
                }
            } else {
                //否则将栈中元素出栈入队，直到遇到大于当前操作符或者遇到左括号时
                while (!opStack.isEmpty() && !"(".equals(opStack.peek())) {
                    if (priority(item) <= priority(opStack.peek())) {
                        suffixList.add(opStack.pop());
                    } else {
                        break;
                    }
                }
                //当前操作符压栈
                opStack.push(item);
            }
        } else if (isNumber(item)) {
            suffixList.add(item);
        } else if (isString(item)) {
            suffixList.add(item);
        } else if ("(".equals(item)) {
            //是左括号，压栈
            opStack.push(item);
        } else if (")".equals(item)) {
            int opParamNumber = 0;
            //是右括号 ，将栈中元素弹出入队，直到遇到左括号，左括号出栈，但不入队
            while (!opStack.isEmpty()) {
                if ("(".equals(opStack.peek())) {
                    opStack.pop();
                    if ("S".equals(opStack.peek())) {
                        //左括号的下一个是S，那么S加上参数个数，出栈 入队
                        String op = opStack.pop();
                        opParamNumber += 1;
                        suffixList.add(op + opParamNumber);
                    }
                    if ("D".equals(opStack.peek())) {
                        //左括号的下一个是D，出栈 入队
                        suffixList.add(opStack.pop());
                    }
                    break;
                } else {
                    String pop = opStack.pop();
                    if (",".equals(pop)) {
                        opParamNumber++;
                    } else {
                        suffixList.add(pop);
                    }
                }
            }
        } else {
            throw new RuntimeException("有非法字符！");
        }
    }
    //循环完毕，如果操作符栈中元素不为空，将栈中元素出栈入队
    while (!opStack.isEmpty()) {
        suffixList.add(opStack.pop());
    }
    return suffixList;
}

执行结果：

中缀：

[1, -, 2.5, +, S, (, 3, *, 4, , 5, , S, (, I, (, 皮卡, =, 皮卡丘, , 5, , D, (, 2022-10-19, , 2022-10-29, ), ), , 6, ), )]

后缀：

[1, 2.5, -, 3, 4, *, 5, 皮卡, 皮卡丘, =, 5, 2022-10-19, 2022-10-29, D, I, 6, S2, S3, +]

这里把SUM函数的参数个数拼在操作符后面了，方便后续计算

最后计算

后缀表达式列表循环，如果是数字，入栈，如果是操作符，弹栈，计算

/**
 * 计算
 */
private static Object calculate(List<String> suffixList) {
    Stack<Object> stack = new Stack<>();
    //遍历ls
    for (String item : suffixList) {
        if ((isNumber(item) || isString(item)) && !isOperator(item)) {
            //如果是参数（数字、字符串）
            //入栈
            stack.push(item);
        } else if (isSimpleOp(item)) {
            //加减乘除
            stack.push(doSimple(stack, item));
        } else if (isFlagOp(item)) {
            //等式运算
            stack.push(doJudge(stack, item));
        } else if (item.startsWith("S")) {
            //sum
            BigDecimal result = doSum(stack, item);
            stack.push(result);
        } else if (item.startsWith("I")) {
            //if
            String falseRes = stack.pop().toString();
            String trueRes = stack.pop().toString();
            String flag = stack.pop().toString();
            stack.push(doIf(flag, trueRes, falseRes));
        } else if (item.startsWith("D")) {
            //days
            Integer days = doDays(stack);
            stack.push(days);
        }
    }
    //将最后的stack中的数弹出
    return stack.pop();
}

执行

public static void main(String[] args) {

    String expression = "1-2.5+SUM(3*4,5,SUM(IF(\"皮卡\"=\"皮卡丘\",5,DAYS(\"2022-10-19\",\"2022-10-29\")),6))";
    List<String> expressionList = expressionToList(expression);

    System.out.println("中缀：" + expressionList);
    List<String> suffixList = parseToSuffixExpression(expressionList);

    System.out.println("后缀：" + suffixList);

    System.out.println("结果：" + calculate(suffixList));
}

执行结果：

中缀：[1, -, 2.5, +, S, (, 3, *, 4, , 5, , S, (, I, (, 皮卡, =, 皮卡丘, , 5, , D, (, 2022-10-19, , 2022-10-29, ), ), , 6, ), )]
后缀：[1, 2.5, -, 3, 4, *, 5, 皮卡, 皮卡丘, =, 5, 2022-10-19, 2022-10-29, D, I, 6, S2, S3, +]
结果：31.5

这个实现只能说勉强能用，可维护性比较差，如果要添加新的规则比较复杂的函数，需要去上面改改逻辑，想办法兼容。

后面可能会想别的办法优化。

这里是 可拓展自定义函数的字符串公式计算优化方案

下面是上面三个方法中用到的一些非主要逻辑代码

具体计算

/**
 * 计算天数函数
 */
private static Integer doDays(Stack<Object> stack) {
    long result;
    try {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate endDay = LocalDate.parse(stack.pop().toString(), formatter);
        LocalDate startDay = LocalDate.parse(stack.pop().toString(), formatter);
        result = startDay.until(endDay, ChronoUnit.DAYS);
    } catch (Throwable e) {
        throw new EqException(EqErrorEnum.E_06);
    }

    return Integer.parseInt(Long.toString(result));
}

/**
 * 加减乘除运算
 */
private static Object doSimple(Stack<Object> stack, String op) {
    //pop出两个数，并运算
    BigDecimal num2 = BigDecimal.ZERO;
    BigDecimal num1 = BigDecimal.ZERO;
    try {
        num2 = new BigDecimal(stack.pop().toString());
        num1 = new BigDecimal(stack.pop().toString());
    } catch (Throwable e) {
        throw new EqException(EqErrorEnum.E_02);
    }
    BigDecimal res = BigDecimal.ZERO;
    if (op.equals("+")) {
        res = num1.add(num2);
    } else if (op.equals("-")) {
        res = num1.subtract(num2);
    } else if (op.equals("*")) {
        res = num1.multiply(num2);
    } else if (op.equals("/")) {
        if (num2.compareTo(BigDecimal.ZERO) == 0) {
            throw new EqException(EqErrorEnum.E_03);
        }
        res = num1.divide(num2);
    } else {
        throw new EqException(EqErrorEnum.E_04);
    }
    return res;
}

/**
 * SUM函数
 */
private static BigDecimal doSum(Stack<Object> stack, String op) {
    int paramNum = Integer.parseInt(op.substring(1));
    BigDecimal result = BigDecimal.ZERO;
    for (int i = 0; i < paramNum; i++) {
        try {
            BigDecimal param = new BigDecimal(stack.pop().toString());
            result = result.add(param);
        } catch (Throwable e) {
            throw new EqException(EqErrorEnum.E_06);
        }
    }
    return result;
}

/**
 * if函数
 */
private static String doIf(String flag, String trueRes, String falseRes) {
    Boolean aBoolean;
    try {
        aBoolean = Boolean.valueOf(flag);
    } catch (Throwable e) {
        throw new EqException(EqErrorEnum.E_06);
    }
    return aBoolean ? trueRes : falseRes;
}

/**
 * 不等式
 */
private static Boolean doJudge(Stack<Object> stack, String item) {
    Object num2 = stack.pop();
    Object num1 = stack.pop();
    boolean res = false;
    if (item.equals("=")) {
        res = num1.equals(num2);
    } else if (item.equals(">")) {
        try {
            BigDecimal param2 = new BigDecimal(num2.toString());
            BigDecimal param1 = new BigDecimal(num1.toString());
            res = param1.compareTo(param2) > 0;
        } catch (Throwable e) {
            throw new EqException(EqErrorEnum.E_02);
        }
    } else if (item.equals("<")) {
        try {
            BigDecimal param2 = new BigDecimal(num2.toString());
            BigDecimal param1 = new BigDecimal(num1.toString());
            res = param1.compareTo(param2) < 0;
        } catch (Throwable e) {
            throw new EqException(EqErrorEnum.E_02);
        }
    } else if (item.equals(">=")) {
        try {
            BigDecimal param2 = new BigDecimal(num2.toString());
            BigDecimal param1 = new BigDecimal(num1.toString());
            res = param1.compareTo(param2) >= 0;
        } catch (Throwable e) {
            throw new EqException(EqErrorEnum.E_02);
        }
    } else if (item.equals("<=")) {
        try {
            BigDecimal param2 = new BigDecimal(num2.toString());
            BigDecimal param1 = new BigDecimal(num1.toString());
            res = param1.compareTo(param2) < 0;
        } catch (Throwable e) {
            throw new EqException(EqErrorEnum.E_02);
        }
    } else if (item.equals("<>")) {
        res = !num1.equals(num2);
    } else {
        throw new EqException(EqErrorEnum.E_04);
    }
    return res;
}

一些判断

private static String replaceFunctionStr(String text) {
    return text.replaceAll("SUM", "S").replaceAll("IF", "I").replaceAll("DAYS", "D");
}
 /**
     * 判断字符串是否为操作符
     */
    public static boolean isOperator(String op) {
        return isSimpleOp(op) || isFlagOp(op) || isExpressOp(op) || isOtherOp(op);
    }

    /**
     * 判断字符串是否为加减乘除
     */
    private static boolean isSimpleOp(String op) {
        return op.equals("+") || op.equals("-") || op.equals("*") || op.equals("/");
    }

    /**
     * 判断字符串是否为等式操作符
     */
    private static boolean isFlagOp(String op) {
        return op.equals(">") || op.equals("<") || op.equals("=") || op.equals(">=") || op.equals("<=") || op.equals("<>");
    }

    /**
     * 判断字符串是否为公式操作符
     */
    private static boolean isExpressOp(String op) {
        return op.startsWith("S") || op.equals("I") || op.equals("D");
    }

    /**
     * 判断字符串是否为其他操作符
     */
    private static boolean isOtherOp(String op) {
        return op.equals(",");
    }

    /**
     * 判断是否为数字
     */
    public static boolean isNumber(String num) {
        return num.matches("\\d+(\\.\\d+)?");
    }

    /**
     * 判断是否为合法字符串参数 允许由汉字 数字 大小写英文字母 和 - 组成的字符串
     */
    private static boolean isString(String num) {
        return num.matches("[\\u4e00-\\u9fa50-9a-zA-Z-]{1,}$");
    }

    /**
     * 获取操作符的优先级
     */
    private static int priority(String op) {
        if (op.equals("*") || op.equals("/") || isFlagOp(op) || isExpressOp(op)) {
            return 1;
        } else if (op.equals("+") || op.equals("-")) {
            return 0;
        }
        return -1;
    }

报错枚举

public enum  EqErrorEnum implements IErrorCode {
    E_01(30001L, "公式解析异常！"),
    E_02(30002L, "四则运算参数异常！"),
    E_03(30003L, "分母不能为0！"),
    E_04(30004L, "运算符有误！"),
    E_05(30005L, "等式运算参数异常！"),
    E_06(30006L, "函数参数异常！"),

    ;
    private Long code;
    private String message;

    EqErrorEnum(Long code, String message) {
        this.code = code;
        this.message = message;
    }

    @Override
    public long getCode() {
        return code;
    }

    @Override
    public String getMessage() {
        return message;
    }
}
LxyrichBos
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
ExpressionParser:计算数学表达式字符串
06-16
表达式解析器 该程序使用“有限状态机”方法解析一串数学表达式并计算其结果。
使用java处理字符串公式运算的方法
09-05
本篇文章介绍了，使用java处理字符串公式运算的方法。需要的朋友参考下
JAVA计算字符串数学表达式及SQL占位符处理
最新发布
weixin_47425074的博客
03-22 302
mySql分页：limit #{(${currentPage} - 1) * ${pageSize}}, ${pageSize}输入字符串长度不超过 100 ，合法的字符包括 ”+, -, *, /, (, )” ， ”0-9”。传入初始的带占位符的sql语句和参数，替换占位符并计算sql中的表达式后返回最终可执行的sql。入参："(5-1)*3" ：输出：12。每页显示记录数：${pageSize}当前页：${currentPage}入参："16/2" ：输出：8。字符串占位符：'${}'
《文本计算器》字符串转数学表达式，支持自定义变量.java
05-08
《文本计算器》字符串转数学表达式，如替换变量前：(a+b+2)+x*3+1 替换变量后：(3+2+2)+4*3+1 计算结果：20
java字符串数学表达式（含括号）计算值
10-17
代码均为自己设计所写，分享一下。 字符串数学表达式（含括号）计算值 如： "31+3*3-20/2*5+40/8+4*5" ((2*(19-13*(1+2)/39)/6+4)-5)/5+((2+3)*2-5)
字符串转换为计算公式的若干种方法
05-18
个人收集的几种将字符串表达式转换为计算公式的方法。
解析字符串公式
洛柒
09-13 703
解析字符串公式-推荐第一种
jeval 公式_关于Java：如何解析以字符串形式给出的数学表达式并返回数字？
weixin_39812142的博客
12-18 434
本问题已经有最佳答案，请猛点这里访问。Java中有没有一种方法可以从以下数学表达式获取结果：String code ="5+4*(7-15)";另一方面，解析算术表达式的最佳方法是什么？您可以将其传递给BeanShell bsh.Interpreter，如下所示：Interpreter interpreter = new Interpreter();interpreter.eval("result...
【工具】JAVA 全角转半角 半角转全角
我是Superman丶的博客
03-17 3622
【工具】JAVA 全角转半角 半角转全角 import cn.hutool.core.util.StrUtil; /** * 字符工具 */ public class CharUtil { /** * 半角转全角的函数(SBC case) * 全角空格为12288,半角空格为32，其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248 * * @param input 任意字符串 * @..
java 使用JEP解析字符串计算公式 求值(附带自定义函数编写)
李虹柏的博客
04-17 6692
1.增加jep依赖 <dependency> <groupId>org.scijava</groupId> <artifactId>jep</artifactId> <version>2.4.2</version> </dependency> 2.计算公式 JEP本...
JAVA如何计算字符串公式
永远年轻
08-05 8271
JAVA如何计算字符串公式解决方案一：使用 commons-jexl3 jar 包解决方案二：使用 JDK 底层调用 javaScript 的运算公式 (推荐使用) 解决方案一：使用 commons-jexl3 jar 包 可以使用 commons-jexl3 jar包，此 jar 包提供了一些方法用于计算字符串中的公式。 maven 依赖如下： <dependency> <groupId>org.apache.commons</groupId> <artifa
java 字符串 四则运算_java解析字符串中的四则运算工具类
weixin_29794879的博客
02-16 159
import java.text.DecimalFormat;import java.text.NumberFormat;import java.text.SimpleDateFormat;import java.util.regex.Matcher;import java.util.regex.Pattern;public class ReportUtil {/*** 格式化日期* @param...
Java递归调用—实现自定义四则运算表达式解析/计算
leaderFLY的博客
08-09 1482
递归的思想，一个大型的复杂的问题，层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程。递归过程中，一定有一个结束条件，当满足这个条件之后，程序就返回，不再继续递归调用。使用递归思想解析一个复杂的表达式，最后解析为最简单的式子。
beanshell学习
ruvuoai的专栏
07-31 162
简介： BeanShell是一种脚本语言，一种完全符合java语法的java脚本语言，并且又拥有自己的一些语法和方法，beanShell是一种松散类型的脚本语言（这点和JS类似）。 下载地址：http://www.beanshell.org 设置环境 l 把;bsh-xx.jar放到$JAVA_HOME/jre/lib/ext文件夹下 l unix: export CLASSPATH...
JAVA解析字符串数学公式
热门推荐
DurantJiang Blogs
09-25 1万+
在最近工作中遇到需要处理可变的数学算法，我本次使用的是jep来解析字符串公式，来达到应对可变的目的。 1：首先，在使用jep之前先引入需要的jar &amp;amp;lt;!--jep--&amp;amp;gt; &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;jep&amp;amp;lt;/groupId&amp;amp;gt; &
Java公式计算（字符串）
m0_62721249的博客
10-08 271
【代码】Java公式计算（字符串）
java 解析字符串 计算,java解析并计算字符串算式
weixin_34889287的博客
03-09 1566
解析并计算，字符串形式的加减乘除算式，我亲测可行的，有如下两种方法：java1. Java自带的，eval方法代码以下：gitimport javax.script.ScriptEngine;import javax.script.ScriptEngineManager;import javax.script.ScriptException;/*** 使用java eval 计算字符串表达式* @...
字符串公式计算，四则运算+常见函数计算+自定义函数，Java实现
一只皮卡狗的博客
10-25 2648
实现数学公式四则运算字符串计算，以及常见函数包括SUM()，IF等函数，以及可拓展的自定义函数，java实现
Java对字符串形式的公式进行计算
zranfly
05-18 989
使用场景： 需要执行一些可配置的公式来计算结果 例如：某些公司工资的计算，分各种计算方案，拿到对应字段替换到公式中进行结果计算 依赖 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-jexl3</artifactId> <version>3.1</version> </d.
java动态计算公式
11-25
Java可以通过动态计算公式来实现数学计算的功能。在Java中，可以使用脚本引擎来实现动态计算公式的功能，常用的脚本引擎包括JavaScript引擎、Groovy引擎等。 首先，需要导入相应的脚本引擎库，例如，对于JavaScript引擎，可以导入javax.script包。 接下来，可以使用以下代码进行动态计算公式： ```java import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script.ScriptException; public class DynamicFormulaCalculation { public static void main(String[] args) { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName("javascript"); try { // 定义需要计算的公式 String formula = "2 * (3 + 4)"; // 执行公式计算 Object result = engine.eval(formula); System.out.println("计算结果：" + result); } catch (ScriptException e) { e.printStackTrace(); } } } ``` 以上代码中，首先通过ScriptEngineManager获取一个脚本引擎管理器，然后使用getEngineByName("javascript")获取JavaScript引擎实例。 然后，定义需要计算的公式，可以使用字符串形式表示。在本例中，公式为2 * (3 + 4)。然后，调用engine.eval()方法执行公式计算，得到计算结果。 最后，将计算结果打印输出。 通过这种方式，我们可以实现动态计算公式的功能，具体的公式可以根据实际需求来定义和改变，从而满足不同的数学计算需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LxyrichBos

老板~坐下喝杯茶啊~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值