如何快速解析规则字符串，实现自动判断？

类似"60＞80 && 60＜90"的规则字符串，满足返回true，反之false，请问怎么写代码执行效率高？

public Boolean isString(int num){
       // 比如"num>70 && num<90",若num变量为80，返回true，若num变量为60，返回false
       String ruleStr1 ="80>70 && 80<90";  // 满足规则返回true
       String ruleStr2 ="60>=70 || 60<90";  // 不满足规则返回false
       return null;
   }

题主可以看一下是不是要这种效果：
假设有两个表达式ruleStr1 ，ruleStr2，给定不同的num，通过一个方法判断表达式是否成立
String ruleStr1 ="num>70 && num<90"; // 满足规则返回true
String ruleStr2 ="num>=70 || num<90"; // 不满足规则返回false
以下代码我是按照这个理解来实现的，你可以看看是否是你想要的效果

import java.util.HashMap;
import java.util.Map;

import org.apache.commons.jexl2.Expression;
import org.apache.commons.jexl2.JexlContext;
import org.apache.commons.jexl2.JexlEngine;
import org.apache.commons.jexl2.MapContext;

public class Test {
    public static Object convertToCode(String jexlExp, Map<String, Object> map) {
        JexlEngine jexl = new JexlEngine();
        Expression e = jexl.createExpression(jexlExp);
        JexlContext jc = new MapContext();
        for (String key : map.keySet()) {
            jc.set(key, map.get(key));
        }
        if (null == e.evaluate(jc)) {
            return "";
        }
        return e.evaluate(jc);
    }

    public static Boolean getResult(int num, String ruleStr){
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("num", num);
        String expression = ruleStr;
        Object  code = convertToCode(expression, map);
        return Boolean.valueOf(code.toString());
    }

    public static void main(String[] args) {
        String ruleStr1 ="num>70 && num<90";  // 满足规则返回true
        String ruleStr2 ="num>=70 || num<90";  // 不满足规则返回false
        System.out.println(getResult(80,ruleStr1));
        System.out.println(getResult(90,ruleStr1));
        System.out.println(getResult(80,ruleStr2));
        System.out.println(getResult(100,ruleStr2));
    }
}

代码如下：

    @Test
    public  void isString() {
        String ruleStr1 ="num>70 && num<90";  // 满足规则返回true
        String ruleStr2 ="num>=70 || num<90";  // 不满足规则返回false
        System.out.println(getBoolean(80, ruleStr1));
        System.out.println(getBoolean(90, ruleStr1));
        System.out.println(getBoolean(80, ruleStr2));
        System.out.println(getBoolean(100,ruleStr2));
    }

    public  boolean getBoolean(int num,String s){
        boolean result;
        if(s.contains("&&")){
            int num1 = Integer.parseInt( StringUtils.substringAfter(StringUtils.substringBefore(s,"&&"), ">").trim());
            int num2 = Integer.parseInt( StringUtils.substringAfter(s, "<").trim());
            result = (num >num1 && num <num2);
        }else{
            int num1 = Integer.parseInt( StringUtils.substringAfter(StringUtils.substringBefore(s,"||"), ">=").trim());
            int num2 = Integer.parseInt(StringUtils.substringAfter(s, "<").trim());
            result = (num >=num1 || num <num2);
        }
        return result;
    }

示例结果：

使用spring的表达式可以直接解析或者找第三库

如有帮助，望采纳

public class booleanStr {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要判断的数字");
        String string = scanner.nextLine();
        System.out.println(booleanString(string));;
    }
    public static Boolean   booleanString(String string){
        int num= Integer.parseInt(string);
//        num来自于控制台输入
//        80 和90 是提前预设的条件
        if (num>80&num<90){
            return true;
        }else {
            return false;
        }
    }
}

这种判断的问题，其实效率都挺高的，并且用&& 只要前面的是false就不会再向后在验证，或者用|| 只要前面的是true就不会再向后在验证

采用正则，如有帮助，请采纳！
比如85或70或100，满足返回true，反之false

import java.util.regex.Pattern;

public class Test {


        public  static  void  main(String[] args) {
            String content = "70";
            String pattern = "^85|70|100$";
            boolean isMatch = Pattern.matches(pattern, content);
            System.out.println( isMatch);//true
        }


    }