如何删除所有的；（）和其中的文本“；在Java字符串中

我需要询问在Java字符串中删除括号和括号内的文本。例如，我有

String str = "I am a new (Software) Engineer"

现在的问题是，如何在不使用

str.replace("(software)", "")

因为可能在下一个字符串中，我会得到“我是一个新的（电气）工程师”或（机械）或类似的东西

---

因此，我如何做到这一点，我认为一种方法是获取“（“and”）”的索引，并使用该索引删除/替换它们，但我希望有一些较短的方法来实现这一点

使用正则表达式匹配括号中的任何内容：

str = str.replaceAll("\\(.*?\\) ?", "");

请注意，括号必须转义，并且转义字符

\

本身必须在字符串中转义，因此使用双反斜杠

术语

*？

是不情愿的匹配，这意味着如果输入中有两个括号中的术语，它不会一直跳到最后一个括号，即如果使用

*

的话，“a（foo）b（bar）c”将变为“a c”，因为它将消耗从第一个打开的括号到最后一个关闭的括号的所有内容

---

我在末尾添加了一个可选空格，这样一旦删除了中间的术语，就不会留下两个相邻的空格。

实际上，最有效、最简单的方法是遍历整个字符串并检查括号。它只需要一次扫描

您还必须跟踪打开和关闭括号的数量，以确保算法对于类似

外部（另一个括号中的文本）再次外部这样的句子是正确的

，这将导致

再次外部

一种或多或少能做到这一点的代码

public class RemoveParenthesis {
    public static void main(String[] args) {
        int open = 0;
        int closed = 0;
        boolean changed = true;
        int startIndex = 0, openIndex = -1, closeIndex = -1;
        String text = "outside (a text (in another) parenthesis) outside again";
        System.out.println("before: " + text);

        while (changed) {
            changed = false;
            for (int a = startIndex; a < text.length(); a++) {
                if (text.charAt(a) == '(') {
                    open++;
                    if (open == 1) {
                        openIndex = a;
                    }
                } else if (text.charAt(a) == ')') {
                    closed++;
                    if (open == closed) {
                        closeIndex = a;
                        text = text.substring(0, openIndex)
                                + text.substring(closeIndex + 1);
                        changed = true;
                        break;
                    }
                } else {
                    if (open == 0)
                        startIndex++;
                    continue;
                }
            }
        }

        System.out.println("after: " + text);
    }
}

公共类移除括号{
公共静态void main（字符串[]args）{
int open=0；
int闭合=0；
布尔值=真；
int startIndex=0，openIndex=-1，closeIndex=-1；
String text=“外部（另一个括号中的文本）再次外部”；
System.out.println（“before:+text”）；
while（已更改）{
更改=错误；
对于（int a=startIndex；a

公共静态字符串移除括号内容（字符串响应）{
char ch；
StringBuilder sb=新的StringBuilder（）；
堆栈=新堆栈（）；
System.out.println（“删除括号内容之前：+响应”）；
对于（int i=0；i

这并不理想：外部

（另一个括号中的文本）

只会删除

（另一个括号中的文本）

@Dariusz yes-它不适用于嵌套括号。OP并没有暗示出现这种情况。让我们看看OP是否可以为我们澄清这一点。对于单括号集，它非常有效。因此，最好使用堆栈来实现这一目的

public static String removeBracketContents(String response) {
        char ch;
        StringBuilder sb = new StringBuilder();
        Stack<Character> stack = new Stack<Character>();
        System.out.println("before removeBracketContents: " + response);
        for (int i = 0; i < response.length(); i++) {
            ch = response.charAt(i);
            switch (ch) {
            case '(':
                stack.push(new Character(ch));
                break;

            case ')':
                if (stack.isEmpty())
                    return response;
                else
                    stack.pop();
                break;
            default:
                if (stack.isEmpty())
                    sb.append(ch);
             break;
            }
        }
        System.out.println("after removeBracketContents: " + sb.toString());
        if (!stack.isEmpty()) {
            System.out.println("Missing ) at end");
            System.out.println("after removeBracketContents: " + response);
            return response;
        } else {
            System.out.println("after removeBracketContents: " + sb.toString());
            return sb.toString();
        }
    }