Java 使用相对于括号的运算符拆分字符串

我希望以下字符串由（相对于括号对的）最外层运算符拆分（在本例中为“+”）：

结果应该是这样的：

1: "((20 + 20) "         and           " a)"
2: "(20 "                and           " ((20 + 20) + 20))"

// locations of top-level operators:
List<Integer> locations = new ArrayList<Integer>();

int level = 0;

for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    }
    else if (c == ')') {
        level--;
    } 
    else if ("+-*/".indexOf(c) >= 0 && level == 1) {
        locations.add(i);
    }
}

class OperatorData implements Comparable<OperatorData> {
    private String token;
    private int level;

    // constructor etc.

    @Override
    public int compareTo(OperatorData other) {
        return Integer.compare(level, other.level);
    }
}

// location of top-level operators:
Map<OperatorData, Integer> operators = new HashMap<>();

int level = 0;
int i = 0;
while (i < str.length()) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    } else if (c == ')') {
        level--;
    } else if (isOperatorChar(c)) {
        final int index = i;
        StringBuilder token = new StringBuilder();
        token.append(c);

        while (isOperatorChar(c = str.charAt(i + 1))) {
            token.append(c);
            i++;
        }

        operators.put(new OperatorData(token.toString(), level), index);
    }

    i++;
}

// find smallest OperatorData in map

---

您不能使用正则表达式执行此操作，但可以尝试以下操作：

1: "((20 + 20) "         and           " a)"
2: "(20 "                and           " ((20 + 20) + 20))"

// locations of top-level operators:
List<Integer> locations = new ArrayList<Integer>();

int level = 0;

for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    }
    else if (c == ')') {
        level--;
    } 
    else if ("+-*/".indexOf(c) >= 0 && level == 1) {
        locations.add(i);
    }
}

class OperatorData implements Comparable<OperatorData> {
    private String token;
    private int level;

    // constructor etc.

    @Override
    public int compareTo(OperatorData other) {
        return Integer.compare(level, other.level);
    }
}

// location of top-level operators:
Map<OperatorData, Integer> operators = new HashMap<>();

int level = 0;
int i = 0;
while (i < str.length()) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    } else if (c == ')') {
        level--;
    } else if (isOperatorChar(c)) {
        final int index = i;
        StringBuilder token = new StringBuilder();
        token.append(c);

        while (isOperatorChar(c = str.charAt(i + 1))) {
            token.append(c);
            i++;
        }

        operators.put(new OperatorData(token.toString(), level), index);
    }

    i++;
}

// find smallest OperatorData in map

然后，您可以遍历此映射并在具有最低嵌套级别的运算符上拆分。该方法可能如下所示：

1: "((20 + 20) "         and           " a)"
2: "(20 "                and           " ((20 + 20) + 20))"

// locations of top-level operators:
List<Integer> locations = new ArrayList<Integer>();

int level = 0;

for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    }
    else if (c == ')') {
        level--;
    } 
    else if ("+-*/".indexOf(c) >= 0 && level == 1) {
        locations.add(i);
    }
}

class OperatorData implements Comparable<OperatorData> {
    private String token;
    private int level;

    // constructor etc.

    @Override
    public int compareTo(OperatorData other) {
        return Integer.compare(level, other.level);
    }
}

// location of top-level operators:
Map<OperatorData, Integer> operators = new HashMap<>();

int level = 0;
int i = 0;
while (i < str.length()) {
    char c = str.charAt(i);

    if (c == '(') {
        level++;
    } else if (c == ')') {
        level--;
    } else if (isOperatorChar(c)) {
        final int index = i;
        StringBuilder token = new StringBuilder();
        token.append(c);

        while (isOperatorChar(c = str.charAt(i + 1))) {
            token.append(c);
            i++;
        }

        operators.put(new OperatorData(token.toString(), level), index);
    }

    i++;
}

// find smallest OperatorData in map

//顶级运算符的位置：
Map操作符=新的HashMap（）；
智力水平=0；
int i=0；
而（i

请付50英镑。说真的，你试过什么？你不能用正则表达式这么做。好吧，真遗憾！：（我目前正在编写一个编译器，其中的操作总是处于偏执状态。是否有其他方法来处理正则表达式和嵌套操作？为什么不循环遍历字符串的字符，用运算符标记索引，然后在到达字符串末尾后，就知道最后一个运算符在哪里，并可以相应地拆分字符串。@K在更简单的。遍历字符串时，保留一个深度计数器，在

（

上增加，在

上减少）

（初始化为

0

）。

如果（currentChar==“+”&&depth==1）{//split here}（（a+1））呢@KevinDiTraglia怎么办？这应该能像预期的那样工作：不会向
位置添加任何内容。但是操作数可以是文字、变量名或运算。这怎么样？我如何读取它们？+1：我喜欢这里的简单逻辑。感谢您的支持this@GunterGribs您可以使用完全相同的方法。在最后一个
else if
中d使用循环控制变量
i
，直到您所使用的字符是空格或括号（意味着您已经超过了变量名称/操作标记）。如果您正在执行类似操作，则可能需要1）使用
，而
-循环，以及2）跟踪顶级非括号标记的开始/结束位置。