java解析公式“(@1+@12)*@10“并计算

最新推荐文章于 2024-02-14 13:44:38 发布
最新推荐文章于 2024-02-14 13:44:38 发布
阅读量319 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46271129/article/details/119040838
版权 
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class StringTest {
    public static void main(String[] args) {
        String str = "(@1+@12)*@10";
        //1、提取数字
        String s = str.replaceAll("[^0-9]", ",");
        List<String> strings = Arrays.asList(s.split(","));
        strings = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

        //2、去除@提取表达式
        Pattern p = Pattern.compile("[\\d.]");
        Matcher m = p.matcher(str);
        while (m.find()) {
            if (!"".equals(m.group()))
                str = str.replace(m.group(), "");
        }
        String[] split = str.split("@");
        //3、拼接新的表达式
        String newd = "";
        for (int i = 0; i < split.length; i++) {
            for (int j = 0; j < strings.size(); j++) {
                if (i == j) {
                    newd =  newd + split[i] +strings.get(j);
                }
            }
        }
        String value = CalculateUtils.calculate(CalculateUtils.strCast(newd));
        System.out.println(value);
    }
}

结果：
在这里插入图片描述
声明：此处引用工具类：https://blog.csdn.net/xuhuanchao/article/details/5536179

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 实现对字符串表达式进行简单的包括函数的运算。
 */
public class CalculateUtils {
    /**
     * 定义运算符
     */
    public static List<String> lc = new ArrayList<String>();
    static {
        lc.add("+");
        lc.add("-");
        lc.add("*");
        lc.add("/");
    }
    /**
     * 定义逻辑运算符
     */
    public static List<String> lj = new ArrayList<String>();
    static {
        lj.add(">");
        lj.add("<");
        lj.add("=");
        lj.add("!");
    }
    /**
     * int数组注释,第一个标识:0自带函数 1自定义函数;第二个标识:参数个数
     */
    public static Map<String, int[]> funMap = new HashMap<String, int[]>();
    static {
        // 自带函数,可利用反射机制
        funMap.put("abs", new int[] { 0, 1 });
        funMap.put("acos", new int[] { 0, 1 });
        funMap.put("asin", new int[] { 0, 1 });
        funMap.put("atan", new int[] { 0, 1 });
        funMap.put("cbrt", new int[] { 0, 1 });
        funMap.put("ceil", new int[] { 0, 1 });
        funMap.put("cos", new int[] { 0, 1 });
        funMap.put("cosh", new int[] { 0, 1 });
        funMap.put("exp", new int[] { 0, 1 });
        funMap.put("expm1", new int[] { 0, 1 });
        funMap.put("floor", new int[] { 0, 1 });
        funMap.put("log", new int[] { 0, 1 });
        funMap.put("log10", new int[] { 0, 1 });
        funMap.put("log1p", new int[] { 0, 1 });
        funMap.put("random", new int[] { 0, 1 });
        funMap.put("rint", new int[] { 0, 1 });
        funMap.put("round", new int[] { 0, 1 });
        funMap.put("signum", new int[] { 0, 1 });
        funMap.put("sin", new int[] { 0, 1 });
        funMap.put("sinh", new int[] { 0, 1 });
        funMap.put("sqrt", new int[] { 0, 1 });
        funMap.put("tan", new int[] { 0, 1 });
        funMap.put("tanh", new int[] { 0, 1 });
        funMap.put("max", new int[] { 0, 2 });
        funMap.put("min", new int[] { 0, 2 });
        // 自定义函数
        funMap.put("if", new int[] { 1, 3 });
        funMap.put("mod", new int[] { 1, 2 });
        funMap.put("int", new int[] { 1, 1 });
    }

    /**
     * 公式初始化转换
     *
     * @param str
     * @return 处理过的计算客串
     */
    public static String strCast(String str) {
        str = str.toLowerCase();// 去除空格，变小写
        /*Pattern p=Pattern.compile("[//u4e00-//u9fa5]");//匹配中文
        Matcher m = p.matcher(str);*/

        if (str == null ? true : str.length() == 0)
            return "0";
        /*if(m.find()){
            return "0";
        }*/
        if (!checkFormula(str))
            return "0";
        str = str.replaceAll("//*-", "**");
        str = str.replaceAll("-//*", "**");
        str = str.replaceAll("/-", "//");
        str = str.replaceAll("-/", "//");
        str = str.replaceAll("//+-", "-");
        str = str.replaceAll("-//+", "-");
        str = str.replaceAll("-", "-");
        str = str.replaceAll("//*//*", "*-");
        str = str.replaceAll("//", "/-");
        str = str.replaceAll(" ", "");
        return str;
    }

    /**
     * 检查公式中括号出现次数是否正确
     *
     * @param formulaStr
     * @return 公式中的括号是否成对
     */
    public static boolean checkFormula(String formulaStr) {
        boolean flag = true;
        int count = 0;
        for (int i = 0; i < formulaStr.length(); i++) {
            String s = String.valueOf(formulaStr.charAt(i));
            if ("(".equals(s))
                count++;
            else if (")".equals(s))
                count--;
        }
        flag = count == 0;
        return flag;
    }

    /**
     * 分割函数
     *
     * @param str
     * @param bs
     * @return 分割后的客串
     */
    public static String[] spliteFun(String str, String bs) {
        List<String> list = new ArrayList<String>();
        String bds = "";
        int bracket = 0;
        int len = str.length();
        for (int i = 0; i < len; i++) {
            String s = String.valueOf(str.charAt(i));
            if ("(".equals(s)) {
                bracket++;
            } else if (")".equals(s)) {
                bracket--;
            }

            if (bracket == 0 && bs.equals(s)) {
                list.add(bds);
                bds = "";
                continue;
            }

            bds += s;
        }

        list.add(bds);

        String[] ss = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            ss[i] = list.get(i);
        }

        return ss;
    }

    /**
     * 用户自定义函数
     *
     * @param str
     * @param funStr
     * @return 处理用户自定义函数
     */
    public static String customFun(String str, String funStr) {
        String reval = "0";

        String[] gss = spliteFun(str, ",");
        if ("if".equals(funStr)) {
            if (compare(gss[0])) {
                reval = calculate(gss[1]);
            } else {
                reval = calculate(gss[2]);
            }
        } else if ("mod".equals(funStr)) {
            double d2 = new Double(calculate(gss[1]));
            if (d2 == 0)
                return reval;
            double d1 = new Double(calculate(gss[0]));
            reval = (d1 % d2) + "";
        } else if ("int".equals(funStr)) {
            reval = Math.floor(new Double(calculate(gss[0]))) + "";
        }
        return reval;
    }

    /**
     * 逻辑表达式判断
     *
     * @param str
     * @return true or false
     */
    public static boolean compare(String str) {
        boolean flag = false;
        boolean bs = false;
        int len = str.length();
        int bracket = 0;
        String ljbds = "";
        double d_left = 0;
        double d_right = 0;

        for (int i = 0; i < len; i++) {
            String s = String.valueOf(str.charAt(i));
            if ("(".equals(s)) {
                bracket++;
            } else if (")".equals(s)) {
                bracket--;
            }

            if (bracket == 0 && lj.contains(s)) {
                for (int j = i; j < len; j++) {
                    String ts = String.valueOf(str.charAt(j));
                    if (lj.contains(ts)) {
                        ljbds += ts;
                    } else {
                        bs = true;
                        break;
                    }
                }
            }
            if (bs)
                break;
        }

        String[] s = str.split(ljbds);
        d_left = new Double(calculate(s[0]));
        d_right = new Double(calculate(s[1]));

        if ("<".equals(ljbds)) {
            if (d_left < d_right)
                return true;
        } else if (">".equals(ljbds)) {
            if (d_left > d_right)
                return true;
        } else if ("=".equals(ljbds)) {
            if (d_left == d_right)
                return true;
        } else if (">=".equals(ljbds)) {
            if (d_left >= d_right)
                return true;
        } else if ("<=".equals(ljbds)) {
            if (d_left <= d_right)
                return true;
        } else if ("<>".equals(ljbds) || "!=".equals(ljbds)) {
            if (d_left != d_right)
                return true;
        }

        return flag;
    }

    /**
     * 递归调用运算
     *
     * @param str
     * @return String
     */
    public static String calculate(String str) {

        String reval = "";
        String bds = "";
        int bracket = 0;// 对应括号个数
        int pos = 0;
        boolean title = false;

        if (str.substring(0, 1).equals("-")) {
            str = str.substring(1);
            title = true;
        }

        int len = str.length();

        for (int i = 0; i < len; i++) {
            String s = String.valueOf(str.charAt(i));
            pos = i;
            bracket = 0;
            if (!lc.contains(s)) {// 如果没遇到运算符
                if ("(".equals(s)) {// 如果遇到左括号
                    if (funMap.containsKey(bds)) {// 如果左括号前是函数
                        for (int j = i + 1; j < len; j++) {// 从左括号后开始循环
                            pos++;// 累计移动字符位数
                            String ts = String.valueOf(str.charAt(j));// 单个字符
                            // reval+=ts;
                            if ("(".equals(ts))// 如果是左括号累计
                                bracket++;
                            else if (")".equals(ts)) {// 如果是右括号进行减少
                                bracket--;
                                if (bracket == -1) {// 如果是-1,标识括号结束
                                    reval = reval.substring(0, reval.length()
                                            - bds.length());// 重新获得去掉函数头的表达式
                                    reval += funCalculate(str.substring(i + 1,
                                            j), bds);// 表达式加上函数结果,形成新表达式
                                    i = pos;// 计数器增加
                                    bds = "";// 函数头清空
                                    break;// 退出本次循环
                                }
                            }
                        }
                    } else {// 如果是普通运算
                        for (int j = i + 1; j < len; j++) {
                            pos++;
                            String ts = String.valueOf(str.charAt(j));
                            if ("(".equals(ts))
                                bracket++;
                            else if (")".equals(ts)) {
                                bracket--;
                                if (bracket == -1) {
                                    reval += calculate(str
                                            .substring(i + 1, pos));
                                    i = pos;
                                    bds = "";
                                    break;
                                }
                            }
                        }
                    }
                } else {// 累加总表达式和最后一个运算数(或函数)
                    bds += s;
                    reval += s;
                }
            } else {// 遇到运算符最后一个运算数(或函数)清空
                bds = "";
                reval += s;
            }
        }

        if (title)
            reval = "-" + reval;
        return szys(reval);
    }

    /**
     * 函数运算
     *
     * @param gs
     * @param funStr
     * @return String
     */
    public static String funCalculate(String gs, String funStr) {
        String rval = "0";
        if (funMap.containsKey(funStr)) {
            int[] csi = funMap.get(funStr);
            try {
                if (csi[0] == 0) {// java内部函数,通过反射调用
                    Class[] cs = new Class[csi[1]];
                    Object[] objs = new Object[csi[1]];
                    String[] gss = zlcs(gs);
                    for (int i = 0; i < csi[1]; i++) {
                        cs[i] = double.class;
                        objs[i] = new Double(calculate(gss[i]));
                    }
                    Class cls = Class.forName("java.lang.Math");
                    Method m = cls.getMethod("abs", cs);
                    rval = String.valueOf(m.invoke(cls, objs));
                } else if (csi[0] == 1) {// 自定义函数
                    rval = customFun(gs, funStr);
                }
            } catch (Exception e) {

            }
        }

        return rval;
    }

    /**
     * 公式里的参数分割
     *
     * @param str
     * @return String[]
     */
    public static String[] zlcs(String str) {
        int len = str.length();
        boolean flag = true;
        String tstr = "";

        for (int i = 0; i < len; i++) {
            String s = String.valueOf(str.charAt(i));
            if ("(".equals(s)) {
                flag = false;
            } else if (")".equals(s)) {
                flag = true;
            }
            if (flag && ",".equals(s)) {
                tstr += "@";
            } else {
                tstr += s;
            }
        }

        return tstr.split("@");

    }

    /**
     * 四则运算表达式处理
     *
     * @param gs
     * @return String
     */
    public static String szys(String gs) {
        gs = gs + "+0"; // 因为下面的计算是遇到符号才进行,所以多加入一个计算符号,不影响值.
        String c1 = "";// 第一个运算符号
        String c2 = "";// 第二个运算符号
        String s1 = "";// 第一个运算数
        String s2 = "";// 第二个运算数
        String s3 = "";// 第三个运算数

        int len = gs.length();
        for (int i = 0; i < len; i++) {
            String s = String.valueOf(gs.charAt(i));// 获得该位置字符并转换成字符串做比较

            if (lc.contains(s)) { // 如果是运算符号
                if (c1.length() == 0)// 如果第一个运算符号为空,加入
                    c1 = s;
                else if (c2.length() == 0) {// 否则,如果第二个运算符号为空,加入
                    c2 = s;// 第二个运算符号
                    if ("+".equals(c2) || "-".equals(c2)) {// 如果第二个运算符号级别低,那么进行计算
                        s1 = _4zys(s1, c1, s2);// 第一个和第二个数计算
                        c1 = c2;// 保存第二个运算符,其他为空
                        c2 = "";
                        s2 = "";
                    }
                } else {// 上述都保存过
                    if ("+".equals(s) || "-".equals(s)) {// 如果第三个运算符级别低,进行运算
                        s2 = _4zys(s2, c2, s3);// 先算第二三个数,保存至第二个
                        s1 = _4zys(s1, c1, s2);// 再算第一二个,保存至第一个
                        c1 = s;// 保存当前运算符,其他为空
                        s2 = "";
                        c2 = "";
                        s3 = "";
                    } else {// 如果第三个运算符级别高
                        s2 = _4zys(s2, c2, s3);// 先算第二三个数,保存至第二个
                        c2 = s;// 前面不动,保存运算符
                        s3 = "";
                    }
                }
            } else if (s1.length() > 0 && c1.length() > 0 && c2.length() == 0) {// 如果第一个数,第一个运算符已保存,第二个运算符未保存,保存第二哥数
                s2 += s;
            } else if (c1.length() == 0) {// 如果没有运算符,保存第一个数
                s1 += s;
            } else if (s1.length() > 0 && s2.length() > 0 && c1.length() > 0
                    && c2.length() > 0) {// 如果第一二个数和运算符都有,保存第三个数
                s3 += s;
            }
        }
        return s1;
    }

    /**
     * 基本四则运算
     *
     * @param c1
     *            运算数1
     * @param s1
     *            运算符(加减乘除)
     * @param c2
     *            运算数2
     * @return String
     */
    public static String _4zys(String c1, String s1, String c2) {
        String reval = "0";

        try {
            double ln = Double.valueOf(c1).doubleValue();
            double rn = Double.valueOf(c2).doubleValue();
            if ("+".equals(s1)) {
                return (ln + rn) + "";
            } else if ("-".equals(s1)) {
                return (ln - rn) + "";
            } else if ("*".equals(s1)) {
                return (ln * rn) + "";
            } else if ("/".equals(s1)) {
                if (rn == 0)
                    return reval;
                else
                    return (ln / rn) + "";
            }
        } catch (Exception e) {
        } finally {
        }

        return reval;
    }
}
胖小八
关注
专栏目录
java执行字符串中的运算公式
安迪的专栏
05-07 3万+
public class runString { static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript"); /** * @param args */ public static void main(String[] args) { String strs = "1+1*
AST抽象语法树解析计算公式_JAVA版（附详细源码）
IT_Most的博客
01-29 868
自创的基于JAVA的AST公式表达式解析方法具备解析：变量（单双引号包裹的字符串）、函数（方法）、数值（整数或小数）、字符串、算数表达式（加减乘除）、括弧表达式和负数表达式的能力。内附全部源码，拿来即用，错过后悔一辈子！
java 字符串公式计算 --------转载
sr_java
01-16 339
import java.lang.reflect.Method; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; /** * 实现对字符串表达式进行简单的包括函数的运算。 * @author 时锐 */ public cla...
【Java 字符串数学运算公式（夹带次方和括号）的计算】
最新发布
qq_36720271的博客
02-14 2032
往后移动，当遇到运算符或者到字符串末尾之间的字符即为幂，然后再换成乘数或者除数的运算形式，这里为什么一再强调乘数或者除数，因为如果指数幂做分母，必须要换成除法的形式，比如1/2^3即需要根据"/"进行判断，然后将其换成1/2/2/2。数学运算公式就不必多介绍了，简单交流一下Java怎么实现数学运算公式的计算，在看到此篇博客前，如果你有需求，可能已经翻阅了无数篇文章了，或许已经得到你想要的答案，不过说不定也还没有找到你想要的，这里分享一下本人在开发中的求与获。时，往栈里面取字符，直到取到。
JAVA如何计算字符串公式
永远年轻
08-05 8741
JAVA如何计算字符串公式解决方案一：使用 commons-jexl3 jar 包解决方案二：使用 JDK 底层调用 javaScript 的运算公式 (推荐使用) 解决方案一：使用 commons-jexl3 jar 包 可以使用 commons-jexl3 jar包，此 jar 包提供了一些方法用于计算字符串中的公式。 maven 依赖如下： <dependency> <groupId>org.apache.commons</groupId> <artifa
字符串公式计算，包含常用数学公式，java实现
一只皮卡狗的博客
10-20 3676
数学公式四则运算字符串计算，包括SUM()，IF等函数，java实现
java解析数学公式
11-27
这个是我自己开发的用java编写的解析简单数学公式的jar， 资源下载积分有点贵，但很值得。 解析的公式可以为：+，-，*，/，max() min(),以及带（）的 公式例如： 344+(344-(34+3434)/90)*45 344.34*2+343.34/3 max...
java把字符串转化成公式计算的示例
08-27
在Java编程中，有时我们需要将接收到的字符串解析并转换为可执行的数学公式进行计算。这在处理动态计算、数据分析或用户输入的表达式时非常有用。在给定的标题和描述中，提到了使用Java实现这个功能的一个示例。下面...
java实现公式解析
热门推荐
南 墙
07-23 2万+
在某些应用中，为了支持灵活性，往往用到自定义的公式。 比如，有如下的原始公式集合： int add(int x, int y): 返回x与y的和 int add(int x, int y, int z): 返回x,y,z三个数的和 int min(int x, int y): 返回x,y中较小的值 int max(int x, int y): 返回x,y中较大的值 int doub...
java实现字符串四则运算公式解析工具类的方法
08-27
* 公式计算的工具类 */ public class FormulaCalculator { private static boolean isRightFormat = true; public static double getResult(String formula){ double returnValue = 0; try{ returnValue = ...
字符串计算公式计算
08-18
java 将字符串公式转直接可以进行计算得出结果。
使用java处理字符串公式运算的方法
12-15
在改进一个关于合同的项目时，有个需求，就是由于合同中非数据项的计算公式会根据年份而进行变更，而之前是将公式硬编码到系统中的，只要时间一变，系统就没法使用了，因此要求合同中各个非基础数据的项都能自定义公式，根据设置的公式来自动生成报表和合同中的数据。 　　显然定义的公式都是以字符串来存储到数据库的，可是java中没有这种执行字符串公式的工具或者类，而且是公式可以嵌套一个中间公式。比如：基础数据dddd是56，而一个公式是依赖dddd的，eeee=dddd*20,而最终的公式可能是这样：eeee*-12+13-dddd+24。可知eeee是一个中间公式，所以一个公式的计算需要知道中间公式和基础数据
Java实现计算字符串表达式
03-17
NULL 博文链接：https://xiaobai1023.iteye.com/blog/469689
谈谈JAVA如何计算字符串公式
Mr.yang
04-11 8602
因为最近忙着面试，也没太多时间分享自己的博客，但因为面试的过程中，碰到了几道类似的算法题，都是输入一个字符串数学公式，输出结果。自己整理了下，希望能和大家交流交流。我是利用谭浩强那本C语言上的算法写的，有不合理出，还喜欢大家批评指正。import java.util.ArrayList; import java.util.List; import java.util.Stack;class Infi
Java对字符串形式的公式进行计算
zranfly
05-18 1055
使用场景： 需要执行一些可配置的公式来计算结果 例如：某些公司工资的计算，分各种计算方案，拿到对应字段替换到公式中进行结果计算 依赖 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-jexl3</artifactId> <version>3.1</version> </d.
【纯java代码实现字符串运算符或公式计算，支持函数，不借助第三方依赖、工具】
qq_47588845的博客
01-02 587
【代码】【纯java代码实现字符串运算符或公式计算，支持函数，不借助第三方依赖、工具】
java 字符串 表达式计算_【JAVA】通过公式字符串表达式计算值,网上的一种方法...
weixin_35943493的博客
02-16 416
public class Test {public static void main(String[] args) {SimpleCalculator s=new SimpleCalculator();String methord="80*(1+0.5)"; //testdouble d=s.evaluate(methord);System.out.println(d);}}import jav...
Java公式计算（字符串）
m0_62721249的博客
10-08 327
【代码】Java公式计算（字符串）
java解析excel公式并计算
05-26
要解析和计算Excel公式，可以使用Apache POI库。下面是一个简单的Java代码示例，演示了如何使用Apache POI中的公式求值器计算Excel公式： ```java import org.apache.poi.ss.usermodel.*; import org.apache.poi....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

胖小八

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值