试试这个。这将拆分所有的运算符和符号，并将它们存储在一个数组中，按顺序，以供进一步处理。它的工作原理是用一个特殊的字符串包围每个运算符，然后拆分该字符串。然后它将结果流式传输，以在返回数组之前捕获任何空字符串。

String [] expressions = { "-23+253=",
                          "4-83767=",
                          "74567*3229765=",
                          "(38+5)*7.6"};

String operands = "([-+/*=()])"; 
 
for (String exp : expressions) {
     String[] tokens = Arrays.stream(exp.replaceAll(operands, "#$1#").split("#"))
             .filter(str->!str.isBlank()).toArray(String[]::new);
     
     System.out.printf("%-15s --> %s%n",exp,Arrays.toString(tokens));
}

字符串
指纹

-23+253=        --> [-, 23, +, 253, =]
4-83767=        --> [4, -, 83767, =]
74567*3229765=  --> [74567, *, 3229765, =]
(38+5)*7.6      --> [(, 38, +, 5, ), *, 7.6]

型

尝试以下操作。

s.replaceAll("(.+?)([-+*/])(-?.+)=", "$1 $2 $3").split(" ")

个字符

下面是我做的一个正则表达式：

[+\-/*](-?\d+)=$

字符串
[+\-/*]-匹配+、-、/和-。-需要转义，否则正则表达式将以不同的方式解析它。
(-?\d+)-一个或多个数字，前面可能有-
=-匹配结尾处的等号
$-文本的结尾

什么 * 可能 * 是更有益的将是一个数学表达式解析器，其中数学表达式的所有组件都可以放置到一个String[]数组中，例如：

/**
 * This method will parse a math expression (equation) string, even with various bracket
 * types or nested brackets and Unicode math operators or numerical
 * characters like PI (𝝅)) into a String[] Array.
 * <p>
 * Signed and unsigned integer or floating point values can be within the
 * supplied mathematical expression.
 * <p>
 * Whitespaces are ignored during parsing and will not be contained within
 * the returned String[] Array as an array element.<br>
 *
 * @param expression (String) The mathematical expression to parse into a String[] Array.<br>
 *
 * @return (String[] Array)
 */
public String[] parseMathExpression(String expression) {
    List<String> list = new ArrayList<>();
    String number = "";
    String[] chr = expression.codePoints()
            .mapToObj(cp -> new String(Character.toChars(cp)))
            .toArray(size -> new String[size]);

    for (String c : chr) {
        if (c.matches("\\s")) {
            if (!number.isEmpty()) {
                list.add(number);
                number = "";
            }
        }
        else if (c.matches("[0-9]") || c.matches("[\\.]") || (c.matches("[-]") && number.isEmpty())) {
            number += c;
        }
        else if (!c.matches("\\d") && !number.isEmpty()) {
            list.add(number);
            number = "";
            list.add(c);
        }
        else {
            list.add(c);
        }
    }
    if (!number.isEmpty()) {
        list.add(number);
    }
    return list.toArray(new String[0]);
}

字符串

用法示例：

System.out.println(Arrays.toString(parseMathExpression("-23+253=")));
// Will Output:  [-23, +, 253, =]

System.out.println(Arrays.toString(parseMathExpression("34-83767=")));
// Will Output:  [34, -, 83767, =]

System.out.println(Arrays.toString(parseMathExpression("-74567*3229765=")));
// Will Output:  [-74567, *, 3229765, =]

System.out.println(Arrays.toString(parseMathExpression("(2+-8)+(8.5-0.5)=")));
// Will Output:  [(, 2, +, -8, ), +, (, 8.5, -, 0.5, ), =]

型

Regex：

下面是一个实用的正则表达式，它允许你使用命名组来精确地选择你想要的：

"^(?<sign>-?)(?<firstNumber>\\d+)(?<operator>[-+*/])(?<numberBehindOp>\\d+)(?<equal>=)"

字符串

说明：

1. (?<sign>-?)一个命名的组，捕获负数-（如果存在?）。它以后可作为sign调用。
2. ^行或字符串的开头。
3. (?<firstNumber>\\d+)一个命名的组，捕获一个或多个数字\d+（对于Java字符串，使用额外的“”进行转义）。稍后可作为firstNumber调用。
4. (?<operator>[-+*/])一个命名的组，捕获操作符[-+*/]，稍后可作为operator调用。
   1.......这是什么？

Demo：

import java.util.regex.*;

public class TestRegex1 {
    public static void main(String[] args) {

        // Inputs to test
        String[] InputLines = {
            "-23+253=",
            "34-83767=",
            "-74567*3229765="
        };

        // Regex
        String pattern = "^(?<sign>-?)(?<firstNumber>\\d+)(?<operator>[-+*/])(?<numberBehindOp>\\d+)(?<equal>=)";
        Pattern r = Pattern.compile(pattern);

        // Test all the inputs
        for (String input : InputLines) {

            // Apply the regex
            Matcher m = r.matcher(input);

            // Display the input string with its captured group named 'numberBehindOp'
            if (m.find()) {
                System.out.println("Input: " + input);
                System.out.println("numberBehindOp: " + m.group("numberBehindOp"));
                // System.out.println("firstNumber: " + m.group("firstNumber"));
                System.out.println();
            } else {
                System.out.println("No match found for input: " + input);
            }
        }
    }
}

型
取消注解此行：

// System.out.println("firstNumber: " + m.group("firstNumber"));

型
查看另一个命名组;）

提示：

为了实现最终的正则表达式，我只需要从一个匹配所有行的正则表达式中重新编译：

"^-?\d+[-+*/]\d+="

型
然后添加了命名组。