java实现输入字符串四则运算

Java实现输入字符串四则运算

1. 流程图

stateDiagram
    [*] --> 输入表达式
    输入表达式 --> 判断表达式合法性
    判断表达式合法性 --> 解析表达式
    解析表达式 --> 转化为逆波兰表达式
    转化为逆波兰表达式 --> 计算逆波兰表达式的值
    计算逆波兰表达式的值 --> 输出结果

2. 详细步骤

2.1 输入表达式

首先，我们需要从用户那里获取一个待解析的数学表达式。可以使用Java的Scanner类来实现输入操作。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数学表达式：");
        String expression = scanner.nextLine();
        scanner.close();

        // 执行下一步
    }
}

2.2 判断表达式合法性

在进行计算之前，我们需要判断用户输入的表达式是否合法。可以通过正则表达式来判断表达式是否符合四则运算的规则。

// 使用正则表达式匹配合法的四则运算表达式
if (!expression.matches("[0-9+\\-*/()\\s]+")) {
    System.out.println("输入的表达式不合法！");
    return;
}

// 执行下一步

2.3 解析表达式

接下来，我们需要将用户输入的表达式进行解析，将其中的数字和运算符分离出来。

// 去除空格
expression = expression.replaceAll("\\s", "");

// 将表达式按照运算符分割成字符串数组
String[] tokens = expression.split("(?<=[-+*/()])|(?=[-+*/()])");

// 执行下一步

2.4 转化为逆波兰表达式

将中缀表达式转化为逆波兰表达式是为了方便计算。我们可以使用栈来实现这一步骤。

import java.util.Stack;

public class Main {
    // ...

    // 判断运算符的优先级
    private static int getPriority(char operator) {
        switch (operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return 0;
        }
    }

    // 转化为逆波兰表达式
    private static String toPostfix(String[] tokens) {
        StringBuilder postfix = new StringBuilder();
        Stack<Character> stack = new Stack<>();

        for (String token : tokens) {
            char c = token.charAt(0);
            if (Character.isDigit(c)) {
                postfix.append(token).append(" ");
            } else if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    postfix.append(stack.pop()).append(" ");
                }
                stack.pop();
            } else {
                while (!stack.isEmpty() && getPriority(stack.peek()) >= getPriority(c)) {
                    postfix.append(stack.pop()).append(" ");
                }
                stack.push(c);
            }
        }

        while (!stack.isEmpty()) {
            postfix.append(stack.pop()).append(" ");
        }

        return postfix.toString().trim();
    }

    public static void main(String[] args) {
        // ...

        String postfix = toPostfix(tokens);

        // 执行下一步
    }
}

2.5 计算逆波兰表达式的值

最后，我们需要计算逆波兰表达式的值。同样使用栈来实现这一步骤。

// 计算逆波兰表达式的值
private static double evaluatePostfix(String postfix) {
    Stack<Double> stack = new Stack<>();

    for (String token : postfix.split("\\s")) {
        if (token.matches("[0-9]+")) {
            stack.push(Double.valueOf(token));
        } else {
            double b = stack.pop();
            double a = stack.pop();
            switch (token) {
                case "+":
                    stack.push(a + b);
                    break;
                case "-":
                    stack.push(a - b);
                    break;
                case "*":
                    stack.push(a * b);
                    break;
                case "/":
                    stack.push(a / b);
                    break;
            }
        }
    }

    return