【工具】算数表达式解析

最新推荐文章于 2022-06-18 17:26:30 发布
最新推荐文章于 2022-06-18 17:26:30 发布
阅读量102 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/jweb/blog/775630
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

package com.servlet.demo.framework.utill;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

/**
 * <b>表达式（JPEL）</b></br>
 * 使用逆波兰算法，支持：
 * <ul>
 * <li><b>算数运算表达式:</b><br/>
 * 加(+)、减(-)、乘(*)、除(/)、求余（%）、幂（^）运算</li>
 * <li><b>关系表达式:</b><br/>
 * 等于（==）、不等于(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)</li>
 * <li><b>逻辑表达式:</b><br/>
 * 且（&&）、或( || )、非( ! )、true、false</li>
 * <li><b>括号优先级表达式:</b><br/>
 * 使用“(表达式)”构造，括号里的具有高优先级。</li>
 * </ul>
 * 不支持三目运算，不支持文本字符串
 * @author Yuanqy
 */
public class ElEngine {
    private final static HashMap<String, Integer> priority = new HashMap<>();

    private static int MIN = 100;
    private static String EOD = "#";

    private static int getPriority(String key) {
        if (priority.get(key) == null) return MIN;
        return priority.get(key);
    }

    /**
     * 执行表达式
     * @param calc
     * @return
     */
    public static Object excute(String calc) {
        Stack<String> s = createReversePolish(calc);
        return calcReversePolish(s);
    }

    static {
        // 加入优先级映射,可继续扩展，级别按百科填写
        // priority.put("?:", 13);
        priority.put("||", 12);
        priority.put("&&", 11);

        priority.put("!=", 7);
        priority.put("==", 7);

        priority.put("<=", 6);
        priority.put(">=", 6);
        priority.put("<", 6);
        priority.put(">", 6);

        priority.put("+", 4);
        priority.put("-", 4);

        priority.put("*", 3);
        priority.put("/", 3);
        priority.put("%", 3);

        priority.put("!", 2);
        priority.put("^", 2);// 幂运算,js引擎是不支持这么写的

        priority.put("(", 1);
        priority.put(")", 1);
    }

    // == 解析 ========================================================
    public static Stack<String> createReversePolish(String source) {
        String[] str = editExpress(source);
        Stack<String> s1 = new Stack<String>();// 运算符
        Stack<String> s2 = new Stack<String>();// 逆波兰
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length; i++) {
            String t = str[i];
            if (t.equals("")) continue;
            if (t.equals(EOD)) {// 结束符
                while (true) {
                    if (s1.size() == 0) break;
                    s2.push(s1.pop());
                }
                break;
            }
            sb.append(t);
            if (isNumber(t)) {
                // 若取出的字符是操作数，则分析出完整的运算数，该操作数直接送入S2栈
                if (!isNumber(str[i + 1])) RefreshTemp(s2, sb);
            } else {
                // 若取出的字符是“（”，则直接送入S1栈顶。
                // 若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。
                if (getPriority(t) == 1) {
                    if (t.equals("(")) {
                        spush(s1, s2, sb.deleteCharAt(sb.length() - 1), sb.toString());
                        s1.push(t);
                    }
                    if (t.equals(")")) {
                        while (true) {
                            String s1t = s1.pop();
                            if (s1t.equals("(")) break;
                            s2.push(s1t);
                        }
                    }
                    sb.setLength(0);// ?
                } else if (isNumber(str[i + 1])) {
                    // 若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，如果该运算符优先级大于S1栈栈顶运算符优先级，则将该运算符进S1栈，
                    // 否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）该运算符优先级，最后将该运算符送入S1栈。
                    spush(s1, s2, sb, t);
                }
            }
        }
        s1.clear();
        return s2;
    }

    private static String[] editExpress(String source) {
        source = "(" + source.replaceAll("\\s*", "") + ")" + EOD;// 去除空格
        source = source.replaceAll("true", "(1==1)");// 支持true/false
        source = source.replaceAll("false", "(0==1)");
        source = source.replaceAll("([^\\d|^)])([+|-])(\\d+)", "$1(0$2$3)");// 支持一元[+-]
        return source.split("");
    }

    private static void spush(Stack<String> s1, Stack<String> s2, StringBuilder sb, String t) {
        while (true) {
            if (s1.size() == 0 || getPriority(t) < getPriority(s1.peek()) || getPriority(s1.peek()) == 1) {
                RefreshTemp(s1, sb);
                break;
            } else {
                s2.push(s1.pop());
            }
        }
    }

    private static void RefreshTemp(Stack<String> rpStack, StringBuilder sb) {
        String str = sb.toString();
        if (str.length() > 0) {
            if ((isNumber(str) || getPriority(str) < MIN)) {
                rpStack.push(sb.toString());
                sb.setLength(0);
            } else {
                throw new ArithmeticException("错误的表达式：" + str);
            }
        }
    }

    private static boolean isNumber(String t) {
        char i = t.charAt(0);// 值判断一个字符
        return (i >= 48 && i <= 57) ? true : false;
    }

    // == 计算 ========================================================
    public static Object calcReversePolish(Stack<String> s2) {
        Stack<Object> no = new Stack<Object>();
        for (String s : s2) {
            if (isNumber(s)) {
                no.push(Double.parseDouble(s));
            } else {
                Object d2 = no.pop();
                Object d1 = 0.0;
                if (!no.isEmpty()) d1 = no.pop();
                switch (s) {
                    case "!":
                        no.push(!((boolean) d2));
                        break;
                    case "+":
                        no.push((double) d1 + (double) d2);
                        break;
                    case "-":
                        no.push((double) d1 - (double) d2);
                        break;
                    case "*":
                        no.push((double) d1 * (double) d2);
                        break;
                    case "/":
                        no.push((double) d1 / (double) d2);
                        break;
                    case "%":
                        no.push((double) d1 % (double) d2);
                        break;
                    case "==":
                        no.push((double) d1 == (double) d2 ? true : false);
                        break;
                    case "!=":
                        no.push((double) d1 != (double) d2 ? true : false);
                        break;
                    case ">=":
                        no.push(((double) d1 >= (double) d2 ? true : false));
                        break;
                    case "<=":
                        no.push(((double) d1 <= (double) d2 ? true : false));
                        break;
                    case ">":
                        no.push(((double) d1 > (double) d2 ? true : false));
                        break;
                    case "<":
                        no.push(((double) d1 < (double) d2 ? true : false));
                        break;
                    case "||":
                        no.push(((boolean) d1 || (boolean) d2 ? true : false));
                        break;
                    case "&&":
                        no.push(((boolean) d1 && (boolean) d2 ? true : false));
                        break;
                    case "^":
                        no.push(Math.pow((double) d1, (double) d2));
                        break;
                }
            }
        }
        return no.pop();
    }

    // == 附加 js 引擎
    /**
     * Must java version >=1.6
     */
    private static ScriptEngine se;

    public static ScriptEngine getSE() {
        if (se == null) se = new ScriptEngineManager().getEngineByName("js");//
        return se;
    }

    public static void main(String[] args) {
        try {
            int i = -10;
            List<String> calcs = new ArrayList<>();
            calcs.add("+11+-22-33 ");
            calcs.add("-(-(-1))+(-3)*(-2)*3/4%(-5)+" + i++);
            calcs.add("-1+2*(3+4)-5+(-2)*8/2+8+0 == 5*6/2-5 && 10%4*3>-1+2*3");
            calcs.add("!false");
            calcs.add("1!=-3-(-4)");
            calcs.add("2>=-2+3");
            calcs.add("1+1");
            calcs.add("true");
            for (String calc : calcs) {
                System.out.println("\n中缀表达式：" + calc);
                System.out.println("逆波兰表达式：" + createReversePolish(calc));
                // == 逆波兰 ========================
                long t1 = System.currentTimeMillis();
                System.out.println("逆波兰=" + excute(calc) + "\ttime:" + (System.currentTimeMillis() - t1));
                // // == JS引擎==========================
                long t3 = System.currentTimeMillis();
                System.out.println("JS引擎=" + getSE().eval(calc) + "\ttime:" + (System.currentTimeMillis() - t3));
                Thread.sleep(500);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果：

中缀表达式：+11+-22-33 
逆波兰表达式：[0, 11, +, 0, 22, -, +, 33, -]
逆波兰=-44.0	time:1
JS引擎=-44.0	time:122

中缀表达式：-(-(-1))+(-3)*(-2)*3/4%(-5)+-10
逆波兰表达式：[0, 1, -, -, -, 0, 3, -, 0, 2, -, *, 3, *, 4, /, 0, 5, -, %, +, 0, 10, -, +]
逆波兰=-6.5	time:1
JS引擎=-6.5	time:1

中缀表达式：-1+2*(3+4)-5+(-2)*8/2+8+0 == 5*6/2-5 && 10%4*3>-1+2*3
逆波兰表达式：[0, 1, -, 2, 3, 4, +, *, +, 5, -, 0, 2, -, 8, *, 2, /, +, 8, +, 0, +, 5, 6, *, 2, /, 5, -, ==, 10, 4, %, 3, *, 0, 1, -, 2, 3, *, +, >, &&]
逆波兰=false	time:1
JS引擎=false	time:3

中缀表达式：!false
逆波兰表达式：[0, 1, ==, !]
逆波兰=true	time:0
JS引擎=true	time:1

中缀表达式：1!=-3-(-4)
逆波兰表达式：[1, 0, 3, -, 0, 4, -, -, !=]
逆波兰=false	time:0
JS引擎=false	time:4

中缀表达式：2>=-2+3
逆波兰表达式：[2, 0, 2, -, 3, +, >=]
逆波兰=true	time:0
JS引擎=true	time:2

中缀表达式：1+1
逆波兰表达式：[1, 1, +]
逆波兰=2.0	time:0
JS引擎=2.0	time:1

中缀表达式：true
逆波兰表达式：[1, 1, ==]
逆波兰=true	time:0
JS引擎=true	time:4

 

转载于:https://my.oschina.net/jweb/blog/775630

weixin_34221773
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
表达式解析计算器源码（完整实现）
David_Jett
01-27 2938
大一下时做的大数非图形界面计算器，自己在这个过程中收获较大，希望和大家分享下 分三个（面向过程浮点版，面向对象浮点版和面向对象大数版）版本:： 完整实现如下： Version1： 面向过程浮点版 （从文件读入并输出） divexcept.h(存储各种错误信息) #include #include using namespace std; string return_except(
表达式计算解析（1）
最新发布
Lohax的博客
10-16 58
初始化使用统一的函数ExecInitExpr，根据表达式的类型不同选择不用的处理方式。表达式计算和前几篇文章介绍的算子息息相关，很多个算子里面都需要计算表达式，过滤元组，再返回可行元组，因此，弄懂表达式计算至关重要。表达式计划树的好处就是能够把表达式计算分成一个个单元运算，和火山模型一样，上层运算调用下层运算，下层运算结果返回给上层运算，最后顶层结果返回给火山模型中的各个算子进行元组过滤。注意：本例只是一个特殊情况，使得表达式计划树恰好是一棵二叉树，实际上，表达式计划树只是一个更为普遍的树形结构。
数学计算表达式解析
CSDN-ZCL
10-15 3934
写在前面 最近在写一个计算器的项目，其中最麻烦的就是数学表达试的解析，用C语言解决问题，每一步进本都要自己实现，非常锻炼逻辑能力。用了将近两个晚上的时间，终于完成了大部分表达式的解析，写这篇文章来记录下遇到的问题。 问题 动态字符串实现 最棘手的就是动态内存的分配，在这块遇到了很大的困难，经过百度，也是解决了问题。 参考链接：https://blog.csdn.net/ljwy1234/artic...
解析算数表达式
Artisan_w
03-16 544
步骤主要是两部： 1.将算数表达式转换为后缀表达式 2.求后缀表达式的值 在之前首先要明确什么是后缀表达式：在我们写表达式时一般把操作符（+，-，，/）放在两个字符之间，例如A+B，A/B，这个被称为中缀表达式，而后缀表达式是将操作符放在字符后面，于是变成了AB+，AB/。如下表所示所示为典型的变换 首先解决第一个问题：如何将中缀表达式转化为后缀表达式？ 首先解析3+45： 解析3*（4+5）...
计算表达式
Gedulding的博客
05-19 1649
题目描述 对于一个不存在括号的表达式进行计算 输入描述: 存在多种数据，每组数据一行，表达式不存在空格 输出描述: 输出结果 示例1 输入 6/2+3+3*4 输出 18 题目解析：知道符号的优先级，6/2+3+3*4 = 3 + 3 + 12，所以表达式实际上最后是一个加减式。优先计算出/，*的部分表达式，最后将结果加在一起。 代码： #include<stdio.h> #include<math.h> #include<algorithm> #include<s
算数表达式求值
06-22
1. **表达式解析**：算术表达式通常由数字、运算符和括号组成，如 `2 + (3 * 4) - 5`。解析是将这样的字符串转换为内部数据结构的过程，这通常通过语法分析完成。这里，我们可以使用递归下降解析或者使用现成的解析...
python 计算器 支持复杂算数表达式
10-13
Python计算器是一种基于编程语言实现的计算工具，它可以处理不仅仅是简单的加减乘除，还支持复杂的算术表达式。在这个项目中，我们使用Python语言来构建一个递归下降解析器，这是一种解析器设计技术，用于解释输入的...
数据结构学期作品算数表达式求值演示程序说明
03-23
总结，这个算数表达式求值程序运用了数据结构中的栈，结合运算符优先级理论，实现了一个高效、准确的表达式计算工具。它不仅展示了数据结构在实际问题解决中的应用，还为学习者提供了理解和实现这类算法的良好实例。
Q703345 用C++解决数据结构算数表达式问题
10-22
标题“Q703345 用C++解决数据结构算数表达式问题”暗示了我们将关注的是如何解析和求解包含运算符和操作数的数学表达式。在C++中，这通常涉及到字符串处理、栈数据结构以及运算符优先级的管理。 首先，我们需要理解...
解析算术表达式
ljz2016的博客
08-10 829
下面是用栈结构解析算术表达式并计算的方法，只适用于操作数是个位数的（如果需要处理多位数，则修改后缀表达式的存储方式即可）。 由中缀表达式获得后缀表达式 public class StackX { private int maxSize; private char[] stackArray; private int top; public StackX(int ...
表达式计算: 分析与设计
乘风破浪
09-19 1488
作者介绍：刘源, 软件工程师, 上海复旦光华电信部 问题由来 在我做过的一个针对网络设备和主机的数据采集系统中，某些采集到的数据需要经过一定的计算后才保存入库，而不是仅仅保存其原始值。为了提供给用户最大的灵活性，我设想提供一个用户界面，允许用户输入计算表达式（或者称为计算公式）。这样，除了需要遵从少量的规则，用户可以得到最大的灵活性。 这样的表达式具有什么特点呢？它一般不是纯的可立即计算
C++实现对数学基本运算表达式的解析
热门推荐
Yorhom's Game Box
08-04 1万+
前段时间在LeetCode上刷题，遇到了很多涉及对字符串进行解析的题目。可能是出于这个原因，最近迷恋上了字符串的解析问题。数学基本运算表达式的解析就涉及这类问题。所谓数学基本运算表达式的解析就是指给定一个表达式字符串，如1 + 1，3 * 9，对这个字符串进行解析，从而得到这个表达式的运算结果。（数学基本运算表达式也就是只用加减乘除进行计算的数学表达式）其实站在我的角度来看，我觉得对数学基本运算表达
字符串表达式解析与计算
qq_42705770的博客
02-07 443
编译原理学完了，想写一个解析数学表达式的程序 看网上的代码大多长且思路混乱 自己写了一个，基本原理是算符优先的归约法，所有函数写在了一个类里 calc函数即可计算 #include<stack> #include<map> using namespace std; class StrParse { public: map<char, int> pr...
表达式的语法解析（表达式计算器2）
weixin_30337157的博客
02-11 278
计算器的github下载地址：https://github.com/ljian1992/calculator 巴科斯范式（BNF） 1.在双引号中的字("word")代表着这些字符本身。而double_quote用来代表双引号。 2.在双引号外的字（有可能有下划线）代表着语法部分。 3.尖括号( < > )内包含的为必选项。 4.方括号( [ ] )内包含的为可选项。 5.大括号( {...
表达式的动态解析和计算，Flee用起来真香
zyq025的专栏
06-18 282
这个解析用着感觉不错哦
四则混合运算表达式分析程序的原理及其实现
oohacker的专栏
09-26 1万+
意义： 四则混合运算表达式可以看作一定语言中的表达式分析及求值，虽然它很小，却是一个语法分析的很好的例子！一、目标：可以对输入的四则混合运算表达式进行分析，并求出其结果。程序须支持：整数及小数运算、支持加（+），减（-），乘（*），除（/），技术括号嵌套。二、原理：表达式的分析过程可以看作三步，（1）分析出表达式中各个标记，包括数值、括号以及操作符，将这些标记按顺序存放起来；（2）根据
整数算数表达式代码实现
03-09
好的，整数算数表达式代码实现可以使用 C 语言中的算术运算符和表达式来实现。例如，可以使用加号、减号、乘号和除号来执行加、减、乘和除运算。此外，还可以使用括号来改变运算的优先级。例如，以下代码实现了一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值