java中解析计算公式

最新推荐文章于 2024-07-14 03:21:56 发布
最新推荐文章于 2024-07-14 03:21:56 发布
阅读量3.5k 收藏 7
点赞数 3
文章标签： java

数据类型为BigDecimal，涉及到金额计算最好用BigDecimal.

package com.nantian.iwap.app.util;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 公式运算
 * */
public class SZYSUtils {

	private static BigDecimal BigDecimalCal(BigDecimal a1, BigDecimal a2, char operator) throws Exception {
        switch (operator) {
        case '+':
        	return a1.add(a2);
            //return a1 + a2;
        case '-':
        	return a1.subtract(a2);
            //return a1 - a2;
        case '*':
        	return a1.multiply(a2);
            //return a1 * a2;
        case '/':
        	return a1.divide(a2,20,BigDecimal.ROUND_HALF_UP);
            //return a1 / a2;
        default:
            break;
        }
        throw new Exception("illegal operator!");
    }

	private static int getPriority(String s) throws Exception {
        if(s==null) return 0;
        else if(s.equals("(")) return 1;
        else if(s.equals("+") || s.equals("-")) return 2;
        else if(s.equals("*") || s.equals("/")) return 3;
        
        /*
        switch(s) {
        case "(":return 1;
        case "+":;
        case "-":return 2;
        case "*":;
        case "/":return 3;
        default:break;
        }
        */
        
        throw new Exception("illegal operator!");
    }

	public static String getResult(String expr) throws Exception {
       // System.out.println("计算"+expr);
        /*数字栈*/
        Stack<BigDecimal> number = new Stack<BigDecimal>(); 
        /*符号栈*/
        Stack<String> operator = new Stack<String>();
        operator.push(null);// 在栈顶压人一个null，配合它的优先级，目的是减少下面程序的判断

        /* 将expr打散为运算数和运算符 */
        Pattern p = Pattern.compile("(?<!\\d)-?\\d+(\\.\\d+)?|[+\\-*/()]");// 这个正则为匹配表达式中的数字或运算符
        Matcher m = p.matcher(expr);
        while(m.find()) {
            String temp = m.group();
            if(temp.matches("[+\\-*/()]")) {//遇到符号
                if(temp.equals("(")) {//遇到左括号，直接入符号栈
                    operator.push(temp);
                    //System.out.println("符号栈更新："+operator);
                }else if(temp.equals(")")){//遇到右括号，"符号栈弹栈取栈顶符号b，数字栈弹栈取栈顶数字a1，数字栈弹栈取栈顶数字a2，计算a2 b a1 ,将结果压入数字栈"，重复引号步骤至取栈顶为左括号，将左括号弹出
                    String b = null;
                    while(!(b = operator.pop()).equals("(")) {
                       // System.out.println("符号栈更新："+operator);
                        BigDecimal a1 = number.pop();
                        BigDecimal a2 = number.pop();
                       // System.out.println("数字栈更新："+number);
                       // System.out.println("计算"+a2+b+a1);
                        number.push(BigDecimalCal(a2, a1, b.charAt(0)));
                       // System.out.println("数字栈更新："+number);
                    }
                    //System.out.println("符号栈更新："+operator);
                }else {//遇到运算符，满足该运算符的优先级大于栈顶元素的优先级压栈；否则计算后压栈
                    while(getPriority(temp) <= getPriority(operator.peek())) {
                        BigDecimal a1 = number.pop();
                        BigDecimal a2 = number.pop();
                        String b = operator.pop();
//                        System.out.println("符号栈更新："+operator);
//                        System.out.println("数字栈更新："+number);
//                        System.out.println("计算"+a2+b+a1);
                        number.push(BigDecimalCal(a2, a1, b.charAt(0)));
//                        System.out.println("数字栈更新："+number);
                    }
                    operator.push(temp);
//                    System.out.println("符号栈更新："+operator);
                }
            }else {//遇到数字，直接压入数字栈
                number.push(new BigDecimal(temp));
//                System.out.println("数字栈更新："+number);
            }
        }

        while(operator.peek()!=null) {//遍历结束后，符号栈数字栈依次弹栈计算，并将结果压入数字栈
            BigDecimal a1 = number.pop();
            BigDecimal a2 = number.pop();
            String b = operator.pop();
//            System.out.println("符号栈更新："+operator);
//            System.out.println("数字栈更新："+number);
//            System.out.println("计算"+a2+b+a1);
            number.push(BigDecimalCal(a2, a1, b.charAt(0)));
//            System.out.println("数字栈更新："+number);
        }
        //System.out.println("值="+number.pop()+"");
        BigDecimal pop = number.pop().setScale(2,BigDecimal.ROUND_HALF_UP);//科学计数，保留2位小数
//        System.out.println(pop.toPlainString());
        return pop.toPlainString();//数值完全显示
       
       /*
        NumberFormat nf = NumberFormat.getInstance();   
        nf.setGroupingUsed(false);  
        String format = nf.format(pop);//科学计数转换成完全显示
        return format;
        */
       // return number.pop()+"";
    }

	
	@SuppressWarnings("null")
	public static void main(String[] args) throws Exception {
//        String str = "0.000000001";
//        str="0.0000001/10000000000";
//        System.out.println(getResult(str));
		String str="1.001";
        BigDecimal a=new BigDecimal(str);
        System.out.println(a.toPlainString());
        
        Double b=Double.valueOf("1.001");
        BigDecimal bb=new BigDecimal(Double.toString(b));
        System.out.println(bb.toPlainString());
       
        BigDecimal cc=new BigDecimal(Double.toString(b));
        System.out.println(cc.toPlainString());
        
        Double d=10000.994;
        DecimalFormat df = new DecimalFormat("#,###.00");
        System.out.println(df.format(d));
        
        BigDecimal bb1=new BigDecimal("2000000.00");
        BigDecimal bb2=new BigDecimal("1999999.999");
        BigDecimal subtract = bb2.subtract(bb1);
        System.out.println(subtract.toPlainString());
       if( subtract.compareTo(BigDecimal.ZERO)==-1){//小于
    	   System.out.println("负");
       }else if( subtract.compareTo(BigDecimal.ZERO)==1){//大于
    	   System.out.println("正");
       }else{//==0等于
    	   System.out.println("0");
       }
        
        Double valueOf = Double.valueOf(1999999.999-2000000.00);
        System.out.println(BigDecimal.valueOf(valueOf).toPlainString());
        
        BigDecimal decimalD=BigDecimal.valueOf(10000.99);
        System.out.println(BigDecimal.valueOf(10000.99).toPlainString());
        System.out.println(decimalD.toPlainString());
        System.out.println(df.format(decimalD));
        
        Double valueOf2 = Double.valueOf("10000000.999");
        BigDecimal de=BigDecimal.valueOf(valueOf2);
        System.out.println(de.toPlainString());
        BigDecimal de2 = new BigDecimal(Double.toString(valueOf2));
        System.out.println(de2.toPlainString());
        BigDecimal de3 = new BigDecimal(valueOf2);
        System.out.println(de3.toPlainString());
        System.out.println(de.doubleValue());
        
        BigDecimal v=new BigDecimal("-0.1");
        if( v.compareTo(BigDecimal.ZERO)==-1){//小于
     	   System.out.println("负");
        }else if( v.compareTo(BigDecimal.ZERO)==1){//大于
     	   System.out.println("正");
        }else{//==0等于
     	   System.out.println("0");
        }
        
        
        String aa=" 123 456 ";
        String trim = aa.trim();
        System.out.println(trim);
        
        String ab=null;
        String trim2 = ab.trim();//报空指针异常
        System.out.println(trim2);
        
      
    }

	
}

数据类型为double,会有精度丢失

package com.nantian.iwap.app.util;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.text.NumberFormat;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 公式运算
 * */
public class SZYSUtils_1 {

	private static double doubleCal(double a1, double a2, char operator) throws Exception {
        switch (operator) {
        case '+':
            return a1 + a2;
        case '-':
            return a1 - a2;
        case '*':
            return a1 * a2;
        case '/':
            return a1 / a2;
        default:
            break;
        }
        throw new Exception("illegal operator!");
    }

	private static int getPriority(String s) throws Exception {
        if(s==null) return 0;
        else if(s.equals("(")) return 1;
        else if(s.equals("+") || s.equals("-")) return 2;
        else if(s.equals("*") || s.equals("/")) return 3;
        
        /*
        switch(s) {
        case "(":return 1;
        case "+":;
        case "-":return 2;
        case "*":;
        case "/":return 3;
        default:break;
        }
        */
        
        throw new Exception("illegal operator!");
    }

	public static String getResult(String expr) throws Exception {
        System.out.println("计算"+expr);
        /*数字栈*/
        Stack<Double> number = new Stack<Double>(); 
        /*符号栈*/
        Stack<String> operator = new Stack<String>();
        operator.push(null);// 在栈顶压人一个null，配合它的优先级，目的是减少下面程序的判断

        /* 将expr打散为运算数和运算符 */
        Pattern p = Pattern.compile("(?<!\\d)-?\\d+(\\.\\d+)?|[+\\-*/()]");// 这个正则为匹配表达式中的数字或运算符
        Matcher m = p.matcher(expr);
        while(m.find()) {
            String temp = m.group();
            if(temp.matches("[+\\-*/()]")) {//遇到符号
                if(temp.equals("(")) {//遇到左括号，直接入符号栈
                    operator.push(temp);
                    //System.out.println("符号栈更新："+operator);
                }else if(temp.equals(")")){//遇到右括号，"符号栈弹栈取栈顶符号b，数字栈弹栈取栈顶数字a1，数字栈弹栈取栈顶数字a2，计算a2 b a1 ,将结果压入数字栈"，重复引号步骤至取栈顶为左括号，将左括号弹出
                    String b = null;
                    while(!(b = operator.pop()).equals("(")) {
                        //System.out.println("符号栈更新："+operator);
                        double a1 = number.pop();
                        double a2 = number.pop();
                       // System.out.println("数字栈更新："+number);
                        //System.out.println("计算"+a2+b+a1);
                        number.push(doubleCal(a2, a1, b.charAt(0)));
                        //System.out.println("数字栈更新："+number);
                    }
                    //System.out.println("符号栈更新："+operator);
                }else {//遇到运算符，满足该运算符的优先级大于栈顶元素的优先级压栈；否则计算后压栈
                    while(getPriority(temp) <= getPriority(operator.peek())) {
                        double a1 = number.pop();
                        double a2 = number.pop();
                        String b = operator.pop();
                        //System.out.println("符号栈更新："+operator);
                        //System.out.println("数字栈更新："+number);
                        //System.out.println("计算"+a2+b+a1);
                        number.push(doubleCal(a2, a1, b.charAt(0)));
                        //System.out.println("数字栈更新："+number);
                    }
                    operator.push(temp);
                    //System.out.println("符号栈更新："+operator);
                }
            }else {//遇到数字，直接压入数字栈
                number.push(Double.valueOf(temp));
                //System.out.println("数字栈更新："+number);
            }
        }

        while(operator.peek()!=null) {//遍历结束后，符号栈数字栈依次弹栈计算，并将结果压入数字栈
            double a1 = number.pop();
            double a2 = number.pop();
            String b = operator.pop();
            //System.out.println("符号栈更新："+operator);
            //System.out.println("数字栈更新："+number);
            //System.out.println("计算"+a2+b+a1);
            number.push(doubleCal(a2, a1, b.charAt(0)));
            //System.out.println("数字栈更新："+number);
        }
       // System.out.println("值="+number.pop()+"");
        Double pop = number.pop();//科学计数
        NumberFormat nf = NumberFormat.getInstance();   
        nf.setGroupingUsed(false);  
        String format = nf.format(pop);//科学计数转换成完全显示
        return format;
       // return number.pop()+"";
    }

	
	public static void main(String[] args) throws Exception {
        String str = "-3.5*(4.5-(4+(-1-1/2)))";
        str="(1.4-1)*3-5*(2.1-1)";
        System.out.println(getResult(str));
        
        
    }

	
}
小小佰
关注
AST抽象语法树解析计算公式_JAVA版（附详细源码）
IT_Most的博客
01-29 856
自创的基于JAVA的AST公式表达式解析方法具备解析：变量（单双引号包裹的字符串）、函数（方法）、数值（整数或小数）、字符串、算数表达式（加减乘除）、括弧表达式和负数表达式的能力。内附全部源码，拿来即用，错过后悔一辈子！
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解析数学公式
11-27
这个是我自己开发的用java编写的解析简单数学公式的jar， 资源下载积分有点贵，但很值得。 解析的公式可以为：+，-，*，/，max() min(),以及带（）的 公式例如： 344+(344-(34+3434)/90)*45 344.34*2+343.34/3 max(1,23,4)*min(3,34) max(34,545)/max(1.2,323.4) max(34,545,56)+max(23.4,5465.5,656.34)+min(1.2,34.5,344.45) 调用代码为 Expression obj = new Expression(fumla); double re = obj.getResult(); fumla为公式 re为计算结果
java通过字符串公式解析数据
最新发布
weixin_36681684的博客
07-14 45
实现Java通过字符串公式解析数据 流程 通过以下步骤来实现Java通过字符串公式解析数据： erDiagram 数据解析步骤 { 数据源 --> 读取数据 读取数据 --> 解析公式 解析公式 --> 计算结果 }每一步如何实现 1. 读取...
java实现数学公式的解析
九九的Spring
11-03 6725
使用java实现数学公式的解析 在最近的项目中，遇到了解析数学公式的业务场景，针对的是对于等式是否成立的判断。网上百度后，搜索到一个jdk提供了引入javascript实现此功能。具体代码如下： public static void main(String[] args) throws Exception { ScriptEngine js = new ScriptEngineManager().getEngineByName("JavaScript"); Object r
Java数学公式解析
az44yao的专栏
12-04 2408
常见的工具包 PARSII ：28.3毫秒 曝光 ：37.2毫秒 MathEval ：7748.5毫秒 JEP ：647.0毫秒 MESP ：220.8毫秒 JFEP ：274.3毫秒 parsii JEval JEPLite expr Janino MathEval <dependency> <groupId>com.scireum</groupId> <artifactId>parsii</artifactId> &
Java实现常用加减乘除公式解析及计算-1.0
YJLTF的博客
07-04 6027
近期接到一个实现公式解析计算、能够多层嵌套并自动拆解的需求。即对于给定的字符串公式进行解析及计算，实现从持久层自动装载公式，拆解多层嵌套的公式，得到计算结果。大致的设计思路为：定义一个计算器基类，实现基本属性的装载及加减乘除公式的定义，实现公式拆解、运算符分级及解析计算；定义子类实现不同的装载逻辑和公式解析逻辑。基类： 解析json格式数据的子类： 测试数据： 测试类： 测试结果：.........
java把字符串转化成公式计算的示例
08-27
在Java编程中，有时我们需要将接收到的字符串解析并转换为可执行的数学公式进行计算。这在处理动态计算、数据分析或用户输入的表达式时非常有用。在给定的标题和描述中，提到了使用Java实现这个功能的一个示例。下面...
java 公式计算汇总，直接调用其方法即可进行运算
09-06
在Java编程语言中，公式计算是一项常见的需求，特别是在科学计算、数据分析、数学建模等领域。为了简化这方面的代码编写，开发者经常会将各种计算操作封装成方法，以便在项目中直接调用。标题“java 公式计算汇总，...
Java 数学表达式解析器
07-04
可以支持复杂的数学表达式（常量、变量、带括号）的计算 如123 + (a * 456)/c - (d + 789) 输入变量值，展示计算步骤和结果 目前支持+ - * / 幂 cos等操作 操作符可方便扩展
CalcEngine4J:Java的计算解析器，评估器和转换器。 解析公式并求值。 允许您使用域模型dsl对相互依赖的公式及其源数据进行建模。 最终目标是能够生成代码以评估此模型中的公式。 这可能是sql存储过程，java代码或我们要使用的任何目标处理逻辑。 CalcEngine允许您声明性地指定公式（“要计算的内容”）并将“如何”推迟到生成器-How to use the source code
03-24
CalcEngine4J:Java的计算解析器，评估器和转换器。 解析公式并求值。 允许您使用域模型dsl对相互依赖的公式及其源数据进行建模。 最终目标是能够生成代码以评估此模型中的公式。 这可能是sql存储过程，java代码或我们要使用的任何目标处理逻辑。 CalcEngine允许您声明性地指定公式（“要计算的内容”）并将“如何”推迟到生成器
java 公式解析源码
03-12
java 公式解析源码，自定义公式解析。
公式解析器（用javacc实现）
06-04
javaCC是一个很好的解析工具，但针对具体应用自己要写一个脚本来应用，然后应用javaCC工具生成java代码即可使用。 在网上的javaCC的应用比较少，也没有太多资料，希望能帮到大家。 这是一个针对公式解析的脚本，打开后可用java直接运行，绝对可用。主要特点如下： * 能够识别负数、小数,但注意出现a--13,这种情况时，就写为a-(-13) * 能够识别字符串 * 能够识别子公式号 * 能够识别多参数函数所需的参数，如max(a,b,c...) * 变量标识除字母、数字、"_"外，还增加"."用于表示子项 * ID（变量名）可以为中文 * 字符串可以中文 * 逻辑标识符加入了NOT的判断，其优先级高于and,or CalcNode.java CalcTree.java SimpleNode.java 三个文件是将解析程序产生的词法树转换为一颗计算树. 这三个类与CalcParser结合使用 注：不要嫌资源分多，这是我辛苦工作的结果，希望得到大家的尊重，谢谢！有什么问题可发站内消息。
数学计算式解析
03-30
支持文本计算式:-1+28(1-3)*Math.max(1,2)字符串解析，自动算出结果； 支持java内嵌函数，zip文件有清单文件 内部机制算法包括：二叉树算法，逆向冒泡算法，Map(映射)和Reduce（规约）翻译算法，cell点阵分布式算法，哈希/耦合算法，Sax单向遍历算法等。 方便分布式云计算订制开发。
java 公式解析器,Java 1.5：数学公式解析器
weixin_33363025的博客
02-16 375
Hello i often develop JTableModels in which some cells must contain the result of apliying a certain simple mathematical formula. This formulas can have:Operators (+,-,*,/)Number constantsOther cell r...
一个用Java编写的公式解析类
lkz的专栏
12-31 3508
初学Java，在工作中需要一个进行公式解析的类。从网上搜到一个相关代码，功能略有欠缺，现修改后能够实现四则运算。为了表示对网友leasion的感谢，并希望能帮助遇到同样问题人，现公开源码如下： /**  * Title: 公式解析类  * Description: 实现对包含“()”的表达式进行简单的四则运算。  * Copyright: Copyright (c) 200
java实现一个简单的数学表达式分析器（加减乘除和括号）
Religion2009的博客
04-23 1190
1.使用此分析器需要输入两个量： String str1=运算符号有前后有空格的数学表达式（如 1 + 2 * ( 3+1) - 5 #）,并在最后添加‘#’字符作为结束标志； String str2=无空格的分割的数学表达式（如 1+2*(3+1)-5#）,同样添加‘#’字符作为结束标志； 2.注：表达式必须严格正确“( )”是不允许存在单个的情况。源代码中有一定的检...
解析计算公式
06-09 470
记得学数据结构的时候是用基于栈的的算法来解析计算公式.现在又如何呢?但其实最简单的,如果有数据库环境的话,直接用sql执行即可.SQL> select 68+11/(55*1)*100 from dual;68+11/(5...
如何在Java中解析Excel公式
葡萄城技术团队博客
02-27 1423
在日常工作中，我们经常需要在Excel中使用公式对表中数据进行计算（求和、求差和求均值等）和分析，从而实现对数据的分类，通常情况下，当数据量较少或场景变化单一的情况下，使用公式可以满足用户的要求，但当数据量较大或者场景变化复杂的情况下，使用公式也无法满足用户的需求的情况。这个时候就可以用编码的方式来解决，以下面的背景需求为例，小编将为大家介绍如何使用葡萄城公司的Java API 组件GrapeCity Documents for Excel （以下简称GcExcel）解析Excel中的现有公式并根据需求对其
java计算公式引擎
06-05
Java计算公式引擎是一种用于在Java应用程序中解析和计算数学表达式的工具。使用计算公式引擎，您可以编写包含变量、函数和操作符的表达式，并将其计算为数字。Java计算公式引擎可以应用于各种领域，如科学计算、金融...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值