java代码执行字符串中的逻辑运算

最新推荐文章于 2023-02-14 17:55:15 发布
最新推荐文章于 2023-02-14 17:55:15 发布
阅读量6.8k 收藏 5
点赞数
分类专栏： javase 文章标签： java string

方式一:

public class Test
{
  public static void main(String[] args) throws Exception {
         String str = "(a or b) and c";
         str = str.replaceAll("or", "||");
         str = str.replaceAll("and", "&&");
         System.out.println(str);
         ScriptEngineManager manager = new ScriptEngineManager();
         ScriptEngine engine = manager.getEngineByName("js");
         engine.put("a",true);
         engine.put("b",false);
         engine.put("c",true);        
         Object result = engine.eval_r(str);
         System.out.println("结果类型:" + result.getClass().getName() + ",计算结果:" + result);

     }
}

这种方式使用js的方式进行运算，使用较简单，但是当运算double类型的四则运算时结果会出现循环小数,运算结果会出现问题.

方式二(能够保证四则运算精度):

/**
 * @Project:      BizRule     
 * @File:         org.coffeesweet.util.MathExpress.java
 * @Author:       coffeesweet
 * @Date:         2011-3-28
 * @Description:  2011 coffeesweet Inc. All rights reserved.
 */
package org.coffeesweet.util;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



/**
 * @author coffeesweet
 * +,-,*,/四则运算的表达式逆波兰解析计算类,精确计算,应用BigDecimal类处理
 * 支持负数,但规范除整个表达式第一个数为负数时可以不出现在'('后，其它表达式中间任何位置的
 * 负数必须出现在'('后,即：用括号括起来。比如：-3+(-2+1)*10或-3+((-2)+1)*10或(-3)+(-2+1)*10或(-3)+((-2)+1)*10
 */
public class MathExpress {
    /**
     * +
     */
    private final static String OP1 = "+";

    /**
     * -
     */
    private final static String OP2 = "-";

    /**
     * *
     */
    private final static String OP3 = "*";

    /**
     * /
     */
    private final static String OP4 = "/";

    /**
     * ^
     */
//    private final static String OP5 = "^";

    /**
     * %
     */
//    private final static String OP6 = "%";
    /**
     * (
     */
    private final static String OPSTART = "(";

    /**
     * )
     */
    private final static String OPEND = ")";

    /**
     * !用来替代负数前面的'-'
     */
//    private final static String NEGATIVESING = "!";

    /**
     * !用来替代负数前面的'+'
     */
//    private final static String PLUSSING = "@";

    /**
     * '#'用来代表运算级别最低的特殊字符
     */
//    private final static String LOWESTSING = "#";

    //最原始的四则运算式
    private String expBase;

    //经过初始化处理后的四则运算式
    private String expInited;

    //精度
    private int precision=10;

    //取舍模式
    private RoundingMode roundingMode=RoundingMode.HALF_UP;

    //精度上下文
    private MathContext mc;

    //四则运算解析
    private List<String> expList = new ArrayList<String>();

    //存放逆波兰表达式
    private List<String> rpnList = new ArrayList<String>();

    public MathExpress(){
    }

    public MathExpress(String expBase) {
        init(expBase,this.precision,this.roundingMode);
    }

    public MathExpress(String expBase,int precision,RoundingMode roundingMode){
        init(expBase,precision,roundingMode);
    }

    public void init(String expBase,int precision,RoundingMode roundingMode){
        this.expBase = expBase;
        this.precision = precision;
        this.roundingMode = roundingMode;
        this.mc = new MathContext(precision,roundingMode);
        this.expInited = initExpress(expBase);

        StringTokenizer st = new StringTokenizer(this.expInited,"+-*/^%()",true);
        while(st.hasMoreElements()){
            this.expList.add(st.nextElement().toString().trim());
        }

        this.rpnList = initRPN(this.expList);


    }

    /**
     * @return the expBase
     */
    public String getExpBase() {
        return expBase;
    }

    /**
     * @param expBase the expBase to set
     */
    public void setExpBase(String expBase) {
        this.expBase = expBase;
    }

    /**
     * @return the expInited
     */
    public String getExpInited() {
        return expInited;
    }

    /**
     * @param expInited the expInited to set
     */
    public void setExpInited(String expInited) {
        this.expInited = expInited;
    }

    /**
     * @return the precision
     */
    public int getPrecision() {
        return precision;
    }

    /**
     * @param precision the precision to set
     */
    public void setPrecision(int precision) {
        this.precision = precision;
    }

    /**
     * @return the roundingMode
     */
    public RoundingMode getRoundingMode() {
        return roundingMode;
    }

    /**
     * @param roundingMode the roundingMode to set
     */
    public void setRoundingMode(RoundingMode roundingMode) {
        this.roundingMode = roundingMode;
    }

    /**
     * @return the expList
     */
    public List<String> getExpList() {
        return expList;
    }

    /**
     * @param expList the expList to set
     */
    public void setExpList(List<String> expList) {
        this.expList = expList;
    }

    /**
     * @return the rpnList
     */
    public List<String> getRpnList() {
        return rpnList;
    }

    /**
     * @param rpnList the rpnList to set
     */
    public void setRpnList(List<String> rpnList) {
        this.rpnList = rpnList;
    }

    /**
     * @return the mc
     */
    public MathContext getMc() {
        return mc;
    }

    /**
     * @param mc the mc to set
     */
    public void setMc(MathContext mc) {
        this.mc = mc;
    }

    /**
     * 去除空白字符和在负号'-'前加'0',便于后面的StringTokenizer
     * @param exp
     * @return
     */
    private static String initExpress(String exp){
        String reStr = null;
        reStr = exp.replaceAll("\\s", "");
        if(reStr.startsWith("-")){
            reStr = "0"+reStr;
        }
        reStr = reStr.replaceAll("\\(\\-", "(0-");
        return reStr;
    }

    /**
     * 是否是整数或是浮点数,但默认-05.15这种也认为是正确的格式
     * @param str
     * @return
     */
    private boolean isNumber(String str){
        Pattern p = Pattern.compile("^(-?\\d+)(\\.\\d+)?$");
        Matcher m = p.matcher(str);
        boolean isNumber = m.matches();
        return isNumber;
    }

    /**
     * 设置优先级顺序()设置与否无所谓
     * @param sign
     * @return
     */
    private int precedence(String str){
        char sign = str.charAt(0);
        switch(sign){
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            case '^':
            case '%':
                return 3;
            case '(':
            case ')':
//          case '#':
            default:
                return 0;

        }
    }

    /**
     * 转变为逆波兰表达式
     * @param strList
     * @return
     */
    public List<String> initRPN(List<String> strList){
        List<String> returnList = new ArrayList<String>();
        //用来存放操作符的栈
        Stack stack = new Stack();
//      stack.push(LOWESTSING);
        int length = strList.size();
        for(int i=0;i<length;i++ ){
            String str = strList.get(i);
            if(isNumber(str)){
                returnList.add(str);
            }else{
                if(str.equals(OPSTART)){
                    //'('直接入栈
                    stack.push(str);
                }else if(str.equals(OPEND)){
                    //')'
                    //进行出栈操作，直到栈为空或者遇到第一个左括号   
                    while (!stack.isEmpty()) {   
                        //将栈顶字符串做出栈操作   
                        String tempC = stack.pop();   
                        if (!tempC.equals(OPSTART)) {   
                            //如果不是左括号，则将字符串直接放到逆波兰链表的最后   
                            returnList.add(tempC);   
                        }else{   
                            //如果是左括号，退出循环操作   
                            break;   
                        }   
                    }   
                }else{
                    if (stack.isEmpty()) {
                        //如果栈内为空   
                        //将当前字符串直接压栈   
                        stack.push(str);   
                    }else{
                        //栈不空,比较运算符优先级顺序
                        if(precedence(stack.top())>=precedence(str)){
                            //如果栈顶元素优先级大于当前元素优先级则
                            while(!stack.isEmpty() && precedence(stack.top())>=precedence(str)){
                                returnList.add(stack.pop());
                            }
                        }
                        stack.push(str);
                    }
                }
            }
        }
        //如果栈不为空，则将栈中所有元素出栈放到逆波兰链表的最后   
        while (!stack.isEmpty()) {
            returnList.add(stack.pop());
        }
        return returnList;
    }

    /**
     * 计算逆波兰表达式
     * @param rpnList
     * @return
     */
    public String caculate(List<String> rpnList){
        Stack numberStack = new Stack();   

        int length=rpnList.size();   
        for(int i=0;i<length;i++){   
            String temp=rpnList.get(i);   
            if(isNumber(temp)){   
                numberStack.push(temp);   
            }else{   
                BigDecimal tempNumber1 = new BigDecimal(numberStack.pop(),this.mc);

                BigDecimal tempNumber2 = new BigDecimal(numberStack.pop(),this.mc);

                BigDecimal tempNumber = new BigDecimal("0",this.mc);

                if(temp.equals(OP1)){   
                    tempNumber=tempNumber2.add(tempNumber1);   
                }else if(temp.equals(OP2)){   
                    tempNumber=tempNumber2.subtract(tempNumber1);   
                }else if(temp.equals(OP3)){   
                    tempNumber=tempNumber2.multiply(tempNumber1);   
                }else if(temp.equals(OP4)){   
                    tempNumber=tempNumber2.divide(tempNumber1,   
                            precision,   
                            roundingMode);   
                }  
                numberStack.push(tempNumber.toString());   

            }   
        }   

        return numberStack.pop();

    }
    /**
     * 按照类的缺省参数进行计算
     * @return
     */
    public String caculate(){
        return caculate(this.rpnList);
    }

    /**
     * 数字条件表达式精确比较
     * eg: "3.0>2"   "1<5"   "1==5"   "1!=5"   "(1.0+2)>3"  "((-0.9+3)>=2. 1)"
     * 不支持&&,||等连接符
     * @param str
     * @return
     */
    public static boolean compareTo(String strParm){
        boolean reBoolean = false;
        boolean isParentheses = false;//标记是否有()括上整个字符串
        String str = initExpress(strParm);
        Pattern p = Pattern.compile("^\\([\\s\\S]*\\)$");
        Matcher m = p.matcher(str);
        isParentheses = m.matches();
        if(-1==str.indexOf(">=")&&-1==str.indexOf("<=")&&-1==str.indexOf("==")&&-1==str.indexOf("!=")){
            if(-1==str.indexOf(">")&&-1==str.indexOf("<"))
            throw new IllegalArgumentException("异常:条件表达式不正确!");
        }
        if(-1 != str.indexOf(">=")){
            String[] strTemps = str.split(">=");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( -1 == r ){
                reBoolean = false;
            }else{
                reBoolean = true;
            }
        }else if(-1 != str.indexOf("<=")){
            String[] strTemps = str.split("<=");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( 1 == r ){
                reBoolean = false;
            }else{
                reBoolean = true;
            }
        }else if(-1 != str.indexOf("==")){
            String[] strTemps = str.split("==");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( 0 == r ){
                reBoolean = true;
            }else{
                reBoolean = false;
            }
        }else if(-1 != str.indexOf("!=")){
            String[] strTemps = str.split("!=");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( 0 != r ){
                reBoolean = true;
            }else{
                reBoolean = false;
            }
        }else if((-1 != str.indexOf(">")) && (-1 == str.indexOf("="))){
            String[] strTemps = str.split(">");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( 1 == r ){
                reBoolean = true;
            }else{
                reBoolean = false;
            }
        }else if((-1 != str.indexOf("<")) && (-1 == str.indexOf("="))){
            String[] strTemps = str.split("<");
            if(isParentheses){
                strTemps[0] = strTemps[0] + ")";
                strTemps[1] = "(" + strTemps[1];
            }
            int r = new BigDecimal((new MathExpress(strTemps[0]).caculate())).compareTo(new BigDecimal((new MathExpress(strTemps[1]).caculate())));
            if( -1 == r ){
                reBoolean = true;
            }else{
                reBoolean = false;
            }
        }
        return reBoolean;
    }

    public static void main(String...args){
//      MathExpress me = new MathExpress("-(-0.5+0.1)*10+2",10,RoundingMode.HALF_UP);
//      System.out.println(me.getExpList());
//      List<String> tempList = me.initRPN(me.getExpList());
//      System.out.println(tempList);
//      String resultStr = me.caculate(tempList);
//      System.out.println(resultStr);

        MathExpress me = new MathExpress("-(-1.5000000003+0.1)*10+2");
        String resultStr = me.caculate();
        BigDecimal bd = new BigDecimal(resultStr);
        BigDecimal bd2 = bd.setScale(2, RoundingMode.HALF_UP);
        System.out.println(me.caculate());
        System.out.println(bd.toString());
        System.out.println(bd.scale());
        System.out.println(bd2.toString());
        System.out.println(bd2.scale());

//      System.out.println("------------------------------------");
//      Pattern p = Pattern.compile("^\\([\\s\\S]*\\)$");//匹配类似以'('开头')'结尾的字符串
//      Matcher m = p.matcher("(2.  0>2.22)");
//      System.out.println(m.matches());

        boolean reBoolean = MathExpress.compareTo("((-8.0+3)>=2. 1)");
        System.out.println(reBoolean);

    }

    /**
     * 栈
     */
    private class Stack {

        LinkedList<String> stackList = new LinkedList<String>();

        public Stack() {

        }

        /**
         * 入栈
         * @param expression
         */
        public void push(String expression) {
            stackList.addLast(expression);
        }

        /**
         * 出栈
         * @return
         */
        public String pop() {
            return stackList.removeLast();
        }

        /**
         * 栈顶元素
         * @return
         */
        public String top() {
            return stackList.getLast();
        }

        /**
         * 栈是否为空
         * @return
         */
        public boolean isEmpty() {
            return stackList.isEmpty();
        }
    }
}
Zzooper
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现计算字符串表达式
03-17
NULL 博文链接：https://xiaobai1023.iteye.com/blog/469689
java 字符串逻辑表达式运算
最新发布
aiyang6666的博客
11-20 114
【代码】java 字符串逻辑表达式运算。
java代码执行字符串中的逻辑运算方法
08-27
今天小编就为大家分享一篇java代码执行字符串中的逻辑运算方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java 字符串逻辑运算处理
qq_42610605的博客
03-19 1005
背景 数据库存储范围 >=0 和 <=5 需要判断变量 val 是否满足该条件 解决方案 可以利用Java 对js 的支持，将数据库的范围参数组合成 val >=0 && val <=5 然后Java 调用执行js脚本，得出结果。 // java 调用js库 ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName(
java中如何将逻辑运算符字符串转换成逻辑表达式讲解
生活因你而精彩
07-09 4270
方式1： package www.paic.test; import javax.script.*; public class TestScript {  public static void main(String[] args) throws Exception {   //String str = "(a >= 0 && a   String str = "(a > 0)"
逻辑运算 Java 字符串运算
jin_xinyu的博客
06-26 287
逻辑运算 final package base; public class Dame01 { //修饰符，不存在前后顺序 static final double PI=3.1415926; public static void main(String[] args) { System.out.println(PI); } } 加减乘除 package base; public class Dame02 { public static void
Java开发技术大全(500个源代码).
12-02
ArrayString.java 字符串数组 assignTwoDime.java 为二维数组赋值 getMaxElem.java 获取数组中的最大元素 incCapicity.java 演示StingBuffer的容量增长 SortDemo.java 排序示例 travelTwoDime.java 遍历二维...
JAVA基础之java的移位运算
05-19
字符串数组binary 代表了0到15 对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组对应元素binary[n] 中。...
Java 虚拟机面试题全面解析（干货）
04-09
·数值类型可以用2进制字符串表示,并且可以在字符串表示中添加下划线; 钻石型语法; nu值的自动处理。 Java 8 函数式接口 Lambda表达式 接口的增强 运行时数据区域包括哪些? 1.程序计数器 2.Java虚拟机栈 3.本地方法...
廖雪峰 Java 教程.doc
02-25
Java代码助手 使用IDE 使用IDE练习插件 Java程序基础 Java程序基本结构 变量和数据类型 整数运算 浮点数运算 布尔运算 字符和字符串 数组类型 流程控制 输入和输出 if判断 switch多重选择 while循环 ...
Java代码中执行字符串逻辑表达式，即将字符串转换成可执行代码
点点一哈的博客
02-04 977
最近遇到的需求，前端传来一系列数据，其中包括比较符，类似==、>=、!=等比较符号，由客户选择，由于不想使用繁琐的switch/case，以及不想日后需求变动导致的比较符增加而改动代码，便想办法将表达式拼接成字符串，再代码执行得到比较结果。 参考原博客：https://www.dazhuanlan.com/2020/05/30/5ed1dd2cd84cb/ 原博客的写法中，ScriptEngineManager构造参数不填，这种写法在main方法中执行没毛病，而在工程项目代码中有问题。 代码如下
java 逻辑表达式 判断_java实现计算复杂逻辑表达式
weixin_34242698的博客
02-13 1222
/***@authorCarol* 计算表达式* 利用一个操作数栈和一个操作栈来进行计算* 出栈情况：当前字符串为操作并且优先级小于栈顶操作元素或者遇到“)”，将操作栈中栈顶元素出栈，操作数栈中出栈俩元素* 入栈情况：“(”直接入栈，或者当前操作优先级大于栈顶元素则直接入栈，操作数直接入栈*@paramexpression*@return*/public static booleanparse2(...
java 中字符串转为可执行的逻辑表达式
zzwpublic的专栏
05-22 2857
客户有有一个需求，规定了几个运算符，如 ！ & | （ ），然后是一些特定条件进行运算，根据他的条件，可以把表达式简化为 一个 只有0和1进行按条件运行的逻辑表达式。如果把0替换为false ，把1替换为true， 把 | 替换为 || ，把& 替换为 &&，！保持不变，就变成这样的表达式( java表示 )： String str...
java 字符串 逻辑运算符号_Java基础之逻辑运算符、位运算、三元运算符、关于字符串连接符“+”的使用...
weixin_34310322的博客
02-13 300
Java基础之逻辑运算符、位运算、三元运算符、关于字符串连接符“+”的使用逻辑运算符//逻辑运算符 && 、||、!boolean a=true;boolean b=false;System.out.println("a&&b: "+(a&&b));//输出falseSystem.out.println("a||b: "+(a||b));//输出tr...
将字符串转换成java逻辑运算
shil的博客
06-13 768
1 2 3 4 5 6 7 8 9 10 11 12 13 import javax.script.*; public class TestScript {     public static void main(String[] args) throws Exception {      
Java中常用的逻辑运算符
kuaiduoqilai的博客
07-26 4034
Java常用逻辑运算符整理
【Java基础】 算术运算、关系运算、逻辑运算、赋值运算、条件运算符、分钟流程控制
qq_36028783的博客
02-14 354
【代码】【Java基础】 算术运算、关系运算、逻辑运算、赋值运算、条件运算符、分钟流程控制。
Java 程序优化：字符串操作、基本运算方法等优化策略
可口可乐的博客
07-08 543
针对 Java 程序编写过程中的实际问题，本文分为两部分，首先对字符串相关操作、数据切分、处理超大 String 对象等提出解决方案及优化建议，并给出具体代码示例；然后对数据定义、运算逻辑优化等方面提出解决方案及优化建议，并给出具体代码示例。 由于本文所尝试的实验都是基于联想 L430 笔记本，i5-3320CPU，4GB 内存基础上的，其他机器上运行代码可能结果有所不同，请以自己的实验环境为
6、Java基础——Java中的运算符、字符串的声明与使用、字符串的比较、运算符的优先级
CSDN_Loveletter的博客
09-28 529
一、Java运算符 1、赋值运算符（=） 2、算数运算符 3、关系运算符（> 、 >= 、
ScriptEngine.eval也支持字符串运算？
06-08
下面是一个示例代码片段，演示了如何在 Java 中使用 ScriptEngine 执行字符串运算： ```java import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script.ScriptException; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值