java 自定义表达式解析

原创

mob64ca12ed4084 2025-01-04 04:00:19 ©著作权

文章标签 解析器 List 自定义 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob64ca12ed4084的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 自定义表达式解析：深入理解与实用示例

在软件开发中，表达式解析是一个重要的技术，尤其是在需要动态计算或执行用户输入的情况下。Java 自定义表达式解析允许开发者根据特定需求创建解析器，实现对输入表达式的处理。本文将介绍如何自定义表达式解析器，并提供相关的代码示例。

表达式解析的基本概念

表达式解析是将一种格式的数据转换为另一种形式的过程，通常是将字符串形式的表达式转换为可执行代码。自定义表达式解析器通常包含以下步骤：

词法分析：将输入的字符串分解为一系列的标记（tokens）。
语法分析：根据预定义的语法规则，将标记组织成语法树或其他结构。
求值：计算解析后的表达式，返回结果。

构建一个简单的表达式解析器

我们将创建一个简单的表达式解析器，支持基本的四则运算（加法、减法、乘法和除法）。以下是实现这个解析器的步骤：

1. 词法分析

首先，我们需要读取输入字符串，并将其转换为一系列的标记。我们可以使用正则表达式来提取数字和操作符。

import java.util.ArrayList;
import java.util.List;

class Token {
    enum Type {
        NUMBER, PLUS, MINUS, MULTIPLY, DIVIDE, LPAREN, RPAREN, EOF
    }

    Type type;
    String value;

    Token(Type type, String value) {
        this.type = type;
        this.value = value;
    }
}

public class Lexer {
    private String input;
    private int position = 0;

    public Lexer(String input) {
        this.input = input;
    }

    public List<Token> tokenize() {
        List<Token> tokens = new ArrayList<>();
        while (position < input.length()) {
            char current = input.charAt(position);
            if (Character.isDigit(current)) {
                StringBuilder number = new StringBuilder();
                while (position < input.length() && Character.isDigit(input.charAt(position))) {
                    number.append(input.charAt(position));
                    position++;
                }
                tokens.add(new Token(Token.Type.NUMBER, number.toString()));
            } else if (current == '+') {
                tokens.add(new Token(Token.Type.PLUS, Character.toString(current)));
                position++;
            } else if (current == '-') {
                tokens.add(new Token(Token.Type.MINUS, Character.toString(current)));
                position++;
            } else if (current == '*') {
                tokens.add(new Token(Token.Type.MULTIPLY, Character.toString(current)));
                position++;
            } else if (current == '/') {
                tokens.add(new Token(Token.Type.DIVIDE, Character.toString(current)));
                position++;
            } else if (current == '(') {
                tokens.add(new Token(Token.Type.LPAREN, Character.toString(current)));
                position++;
            } else if (current == ')') {
                tokens.add(new Token(Token.Type.RPAREN, Character.toString(current)));
                position++;
            } else {
                position++; // 跳过空白字符
            }
        }
        tokens.add(new Token(Token.Type.EOF, ""));
        return tokens;
    }
}

2. 语法分析

接下来，我们将分析标记以创建语法树。我们的语法树将以递归的方式构建。为了简单起见，这里我们只实现基础的加法和乘法操作。

import java.util.List;

class Parser {
    private List<Token> tokens;
    private int currentPosition = 0;

    public Parser(List<Token> tokens) {
        this.tokens = tokens;
    }

    private Token currentToken() {
        return tokens.get(currentPosition);
    }

    private void advance() {
        currentPosition++;
    }

    public double parse() {
        return expression();
    }

    private double expression() {
        double result = term();
        while (currentToken().type == Token.Type.PLUS || currentToken().type == Token.Type.MINUS) {
            if (currentToken().type == Token.Type.PLUS) {
                advance();
                result += term();
            } else {
                advance();
                result -= term();
            }
        }
        return result;
    }

    private double term() {
        double result = factor();
        while (currentToken().type == Token.Type.MULTIPLY || currentToken().type == Token.Type.DIVIDE) {
            if (currentToken().type == Token.Type.MULTIPLY) {
                advance();
                result *= factor();
            } else {
                advance();
                result /= factor();
            }
        }
        return result;
    }

    private double factor() {
        if (currentToken().type == Token.Type.NUMBER) {
            double value = Double.parseDouble(currentToken().value);
            advance();
            return value;
        }
        throw new RuntimeException("Unexpected token: " + currentToken().value);
    }
}

3. 求值

最后，我们需要一个简单的接口来运行我们的解析器，接收用户输入并输出结果。

public class Calculator {
    public static void main(String[] args) {
        String input = "3 + 5 * (2 - 1)";
        Lexer lexer = new Lexer(input);
        List<Token> tokens = lexer.tokenize();

        Parser parser = new Parser(tokens);
        double result = parser.parse();

        System.out.println("Result: " + result);
    }
}