【JAVA】Java实现逻辑表达式解析与运算

Java实现逻辑表达式解析与运算

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

public class LogicEvaluator {
    public static void main(String[] args) {
        String expression = "${STUDENT_NAME =张三 && (AGE > 18 || GRADE <= 3)}";
        Map<String, Object> variables = new HashMap<>();
        variables.put("STUDENT_NAME", "张三");
        variables.put("AGE", "12");
        variables.put("GRADE", "4");

        boolean result = evaluateLogicExpression(expression, variables);
        System.out.println(result);
    }

    public static boolean evaluateLogicExpression(String expression, Map<String, Object> variables) {
        // 去除大括号
        expression = expression.replace("${", "").replace("}", "");
        if (expression.startsWith("(")){
            expression = expression.replace("(", "").replace(")", "");
        }
        // 处理 "!" 运算符
        if (expression.startsWith("!")) {
            String subExpression = expression.substring(1).trim();
            return !evaluateLogicExpression(subExpression, variables);
        } // 处理 "&&" 运算符
        else if (expression.contains("&&")) {
            String[] parts = expression.split("&&", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return evaluateLogicExpression(leftExpression, variables) && evaluateLogicExpression(rightExpression, variables);
        } // 处理 "||" 运算符
        else if (expression.contains("||")) {
            String[] parts = expression.split("\\|\\|", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return evaluateLogicExpression(leftExpression, variables) || evaluateLogicExpression(rightExpression, variables);
        } // 处理 ">=" 运算符
        else if (expression.contains(">=")) {
            String[] parts = expression.split(">=", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return compareValues(leftExpression, rightExpression, variables) >= 0;
        } // 处理 "<=" 运算符
        else if (expression.contains("<=")) {
            String[] parts = expression.split("<=", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return compareValues(leftExpression, rightExpression, variables) <= 0;
        } // 处理 ">" 运算符
        else if (expression.contains(">")) {
            String[] parts = expression.split(">", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return compareValues(leftExpression, rightExpression, variables) > 0;
        } // 处理 "<" 运算符
        else if (expression.contains("<")) {
            String[] parts = expression.split("<", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return compareValues(leftExpression, rightExpression, variables) < 0;
        } // 处理 "=" 运算符
        else if (expression.contains("=")) {
            String[] parts = expression.split("=", 2);
            String leftExpression = parts[0].trim();
            String rightExpression = parts[1].trim();

            return compareValues(leftExpression, rightExpression, variables) == 0;
        } // 处理单个条件表达式
        else {
            String[] keyValue = expression.split("=");

            String key = keyValue[0].trim();
            String value = keyValue[1].trim().replace("'", "");

            // 根据实际情况进行判断并返回结果
            Object variableValue = variables.get(key);
            if (variableValue instanceof String) {
                return ((String) variableValue).equals(value);
            } else if (variableValue instanceof Integer) {
                return ((Integer) variableValue).equals(Integer.parseInt(value));
            }

            // 如果没有匹配的条件，可以根据实际需求返回 true 或 false
            return false;
        }
    }

    private static int compareValues(String leftExpression, String rightExpression, Map<String, Object> variables) {
        Object leftValue = variables.get(leftExpression);
        Object rightValue = rightExpression;

        if (leftValue instanceof String && rightValue instanceof String) {
            return ((String) leftValue).compareTo((String) rightValue);
        } else if (leftValue instanceof Integer && rightValue instanceof Integer) {
            return Integer.compare((Integer) leftValue, (Integer) rightValue);
        } else {
            throw new IllegalArgumentException("Invalid types for comparison: " + leftExpression + ", " + rightExpression);
        }
    }
}