Java 如何拆分两个连续的括号？

假设我有一个字符串

（（3*5）*（2*23））

和一个字符串数组

[（（3，*，5），*，（2，*，23））]

。我想把前两个括号分开，以便得到

（“

，

”（3）

.Split函数在这种情况下不起作用，它返回的是一个空字符串。

有很多不同的方法来解决类似的问题。这里有一个尝试，它不涉及对原始字符串的任何类型的解析。这也是假设字符串是一个有效的表达式

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Solution {           
    public static void main(String[] args) throws ScriptException{
        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("JavaScript");  //Create a script engine
        String expression = "((3 * 5) * (2 * 23))";
        System.out.println(engine.eval(expression));

        //or you can do it in one line
        System.out.println(new ScriptEngineManager().getEngineByName("JavaScript").eval(expression));
    }
}

---

这将利用内置的JavaScript引擎为您进行计算。希望这会有所帮助！

有很多不同的方法可以解决类似的问题。这里有一种尝试不涉及对原始字符串的任何类型的解析。这也是假设字符串是有效的表达式

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Solution {           
    public static void main(String[] args) throws ScriptException{
        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("JavaScript");  //Create a script engine
        String expression = "((3 * 5) * (2 * 23))";
        System.out.println(engine.eval(expression));

        //or you can do it in one line
        System.out.println(new ScriptEngineManager().getEngineByName("JavaScript").eval(expression));
    }
}

---

这就利用了内置的JavaScript引擎来为您进行评估。希望这能有所帮助！

您可能想要的是

（？=X）

或

（？您可能想要的是
（？=X）
或
（？您需要做的不是拆分文本，而是创建一些允许您解析文本的东西。
下面是帮助您实现最终目标的简单代码示例。我不建议您使用它，但我希望它能让您了解您需要朝哪个方向走：

公共级石灰{

static enum TokenType{
    LEFT_BRACKET,RIGHT_BRACKET,NUMBER,OPERATOR
}

static interface Token {
    TokenType getType();
    String getValue();
}

public static void main(String[] args) {
    String expr = "((3*5)*(2*23))";
    System.out.println(parse(expr));

}

private static String parse(String expr) {
    Token[] tokens = getTokens(expr);
    Stack<Token> stack = new Stack<Token>();
    for (Token token : tokens) {

        if (token.getType()==TokenType.NUMBER && !stack.isEmpty() && token.getType()==TokenType.OPERATOR) {
            stack.push(eval(token, stack.pop(), stack.pop()));
        } else if (token.equals(")")) {
            token = stack.pop();
            stack.pop();
            if (token.getType()==TokenType.NUMBER  && !stack.isEmpty() && isOp(stack.peek())) {
                stack.push(eval(token, stack.pop(), stack.pop()));
            } else {
                stack.push(token);
            }
        } else {
            stack.push(token);
        }
    }
    return stack.pop().getValue();
}



private static Token eval(Token a, Token operator, Token b) {
    switch (operator.getValue()) {
    case "*":
        return createNumberToken((Integer.parseInt(a.getValue()) * Integer.parseInt(b.getValue())));
    }
    //
    return null;
}
 private static Token[] getTokens(String expr) {
        // TODO to be implemented
        return null;
    }
private static Token createNumberToken(int i) {
    // TODO to be implemented
    return null;
}

静态枚举令牌类型{
左括号，右括号，数字，运算符
}
静态接口令牌{
TokenType getType（）；
字符串getValue（）；
}
公共静态void main（字符串[]args）{
字符串expr=“（3*5）*（2*23））”；
System.out.println（parse（expr））；
}
私有静态字符串解析（字符串表达式）{
Token[]tokens=getTokens（expr）；
堆栈=新堆栈（）；
for（令牌：令牌）{
if（token.getType（）==TokenType.NUMBER&&！stack.isEmpty（）&&token.getType（）==TokenType.OPERATOR）{
stack.push（eval（令牌，stack.pop（），stack.pop（））；
}else if（标记等于（“）”）{
token=stack.pop（）；
stack.pop（）；
if（token.getType（）==TokenType.NUMBER&&！stack.isEmpty（）&&isOp（stack.peek（））{
stack.push（eval（令牌，stack.pop（），stack.pop（））；
}否则{
堆栈推送（令牌）；
}
}否则{
堆栈推送（令牌）；
}
}
返回stack.pop（）.getValue（）；
}
专用静态令牌评估（令牌a、令牌运算符、令牌b）{
开关（operator.getValue（））{
案例“*”：
返回createNumberToken（（Integer.parseInt（a.getValue（））*Integer.parseInt（b.getValue（）））；
}
//
返回null；
}
私有静态令牌[]getTokens（字符串表达式）{
//待办事项
返回null；
}
专用静态令牌createNumberToken（int i）{
//待办事项
返回null；
}

}

为了不给你们提供解决方案，我留下了创建标记的方法，但并没有实现。这应该让你们简要了解你们的家庭作业是关于什么的。我还建议你们阅读一下你们需要做的，不是拆分你们的文本，而是创建一些允许你们解析它的东西。
下面是帮助您实现最终目标的简单代码示例。我不建议您使用它，但我希望它能让您了解您需要朝哪个方向走：

公共级石灰{

static enum TokenType{
    LEFT_BRACKET,RIGHT_BRACKET,NUMBER,OPERATOR
}

static interface Token {
    TokenType getType();
    String getValue();
}

public static void main(String[] args) {
    String expr = "((3*5)*(2*23))";
    System.out.println(parse(expr));

}

private static String parse(String expr) {
    Token[] tokens = getTokens(expr);
    Stack<Token> stack = new Stack<Token>();
    for (Token token : tokens) {

        if (token.getType()==TokenType.NUMBER && !stack.isEmpty() && token.getType()==TokenType.OPERATOR) {
            stack.push(eval(token, stack.pop(), stack.pop()));
        } else if (token.equals(")")) {
            token = stack.pop();
            stack.pop();
            if (token.getType()==TokenType.NUMBER  && !stack.isEmpty() && isOp(stack.peek())) {
                stack.push(eval(token, stack.pop(), stack.pop()));
            } else {
                stack.push(token);
            }
        } else {
            stack.push(token);
        }
    }
    return stack.pop().getValue();
}



private static Token eval(Token a, Token operator, Token b) {
    switch (operator.getValue()) {
    case "*":
        return createNumberToken((Integer.parseInt(a.getValue()) * Integer.parseInt(b.getValue())));
    }
    //
    return null;
}
 private static Token[] getTokens(String expr) {
        // TODO to be implemented
        return null;
    }
private static Token createNumberToken(int i) {
    // TODO to be implemented
    return null;
}

静态枚举令牌类型{
左括号，右括号，数字，运算符
}
静态接口令牌{
TokenType getType（）；
字符串getValue（）；
}
公共静态void main（字符串[]args）{
字符串expr=“（3*5）*（2*23））”；
System.out.println（parse（expr））；
}
私有静态字符串解析（字符串表达式）{
Token[]tokens=getTokens（expr）；
堆栈=新堆栈（）；
for（令牌：令牌）{
if（token.getType（）==TokenType.NUMBER&&！stack.isEmpty（）&&token.getType（）==TokenType.OPERATOR）{
stack.push（eval（令牌，stack.pop（），stack.pop（））；
}else if（标记等于（“）”）{
token=stack.pop（）；
stack.pop（）；
if（token.getType（）==TokenType.NUMBER&&！stack.isEmpty（）&&isOp（stack.peek（））{
stack.push（eval（令牌，stack.pop（），stack.pop（））；
}否则{
堆栈推送（令牌）；
}
}否则{
堆栈推送（令牌）；
}
}
返回stack.pop（）.getValue（）；
}
专用静态令牌评估（令牌a、令牌运算符、令牌b）{
开关（operator.getValue（））{
案例“*”：
返回createNumberToken（（Integer.parseInt（a.getValue（））*Integer.parseInt（b.getValue（）））；
}
//
返回null；
}
私有静态令牌[]getTokens（字符串表达式）{
//待办事项
返回null；
}
专用静态令牌createNumberToken（int i）{
//待办事项
返回null；
}

}

为了不给你们现成的解决方案，我把创建标记的方法留了下来。这会让你们简要了解你们的家庭作业是关于什么的。我还建议你们阅读关于
的内容，你们可能会找到解决这个问题的方法，但正则表达式不是语言解析的工具。有限状态自动机更合适。我知道这种情况如果使用有限状态自动机，我会做的更好，我只是不知道怎么做，所以我觉得我把这件事复杂化了很多…你想用这些数据做什么？考虑到你的
（（3*5）*（2*23））输入，你希望得到什么样的输出
。算术表达式regex的结果正是解析语言的工具——这基本上就是它们所做的——它们的功能与有限状态自动机相同。唯一的问题是这种语言不规则：PYou可能会找到解决这个问题的方法，但regex不是解析语言的工具。有限状态自动机更合适。我知道如果使用有限状态自动机，这种情况会更好，我只是不知道怎么做，所以我觉得我很复杂