Java 根据模式拆分字符串

我有一个带模式的字符串

（ab）（bc）（ca）

或

abc

。现在，如果存在

（）

，则需要按如下方式进行插入：

pattern (ab)(bc)(ca)  OP A=ab B= bc C= ca
pattern abc           OP A=a  B=b   C=c
parrtern (abc)b c     OP A=abc B=b  c= c
parrtern a (bb) c     OP A=abc B=bb  c= c

---

如何使用正则表达式像这样拆分字符串？

签出

string.split（…）
 签出
String.split（…）
 您可以使用的类。它可以被许多不同的东西分开

（在问题更新为更多信息之前，我一直这么认为）


Arg，现在您添加了信息，我认为任何拆分方法都不会让您达到目的。然而，这将：

String s = " (abc)b c";
Matcher matcher = Pattern.compile("(?<=\\()[a-z]{2,}(?=\\))|[a-z]").matcher(s);
while (matcher.find()){
    System.out.println(matcher.group());
}

解释的模式：

abc
b
c

(?<=\\()  // match after an opening parenthesis
[a-z]{2,} // match two or more letters
(?=\\))   // match before closing parenthesis
|         // or
[a-z]     // match a single letter

Test: (ab)(bc)(ca)
   Part: ab
   Part: bc
   Part: ca

Test: abc
   Part: a
   Part: b
   Part: c

Test: (abc)b c
   Part: abc
   Part: b
   Part: c

Test: a (bb) c
   Part: a
   Part: bb
   Part: c

Test: (ab)(bc)(ca)       Parts: [ab, bc, ca]
Test: abc                Parts: [a, b, c]
Test: (abc)b c           Parts: [abc, b, c]
Test: a (bb) c           Parts: [a, bb, c]

（？您可以使用的类。它可以被许多不同的东西分割

（在问题更新为更多信息之前，我一直这么认为）


Arg，现在您添加了信息，我认为任何拆分方法都无法让您达到目标。但是，这将：

String s = " (abc)b c";
Matcher matcher = Pattern.compile("(?<=\\()[a-z]{2,}(?=\\))|[a-z]").matcher(s);
while (matcher.find()){
    System.out.println(matcher.group());
}

解释的模式：

abc
b
c

(?<=\\()  // match after an opening parenthesis
[a-z]{2,} // match two or more letters
(?=\\))   // match before closing parenthesis
|         // or
[a-z]     // match a single letter

Test: (ab)(bc)(ca)
   Part: ab
   Part: bc
   Part: ca

Test: abc
   Part: a
   Part: b
   Part: c

Test: (abc)b c
   Part: abc
   Part: b
   Part: c

Test: a (bb) c
   Part: a
   Part: bb
   Part: c

Test: (ab)(bc)(ca)       Parts: [ab, bc, ca]
Test: abc                Parts: [a, b, c]
Test: (abc)b c           Parts: [abc, b, c]
Test: a (bb) c           Parts: [a, bb, c]

（？这里有一种方法。它并不是一次性“拆分”，但这可能是我应该做的

String[] tests = {"(ab)(bc)(ca)", "abc", "(abc)b c", "a (bb) c" };

Pattern p = Pattern.compile("\\s*(\\(.*?\\)|.)\\s*");

for (String test : tests) {
    Matcher m = p.matcher(test);

    System.out.println("Test: " + test);
    while (m.find())
        System.out.println("   Part: " + m.group().replaceAll("[() ]", ""));

    System.out.println();
}

输出：

abc
b
c

(?<=\\()  // match after an opening parenthesis
[a-z]{2,} // match two or more letters
(?=\\))   // match before closing parenthesis
|         // or
[a-z]     // match a single letter

Test: (ab)(bc)(ca)
   Part: ab
   Part: bc
   Part: ca

Test: abc
   Part: a
   Part: b
   Part: c

Test: (abc)b c
   Part: abc
   Part: b
   Part: c

Test: a (bb) c
   Part: a
   Part: bb
   Part: c

Test: (ab)(bc)(ca)       Parts: [ab, bc, ca]
Test: abc                Parts: [a, b, c]
Test: (abc)b c           Parts: [abc, b, c]
Test: a (bb) c           Parts: [a, bb, c]


类似的事情甚至可能会发生（我可能利用了你的例子中的一个属性，而这个属性在你的“真实”问题中并不存在。我讨厌人们对我的问题这样做，所以如果是这样的话，我提前道歉！）：

这里有一种方法。它并不是一次就“分开”，但这可能是我应该做的

String[] tests = {"(ab)(bc)(ca)", "abc", "(abc)b c", "a (bb) c" };

Pattern p = Pattern.compile("\\s*(\\(.*?\\)|.)\\s*");

for (String test : tests) {
    Matcher m = p.matcher(test);

    System.out.println("Test: " + test);
    while (m.find())
        System.out.println("   Part: " + m.group().replaceAll("[() ]", ""));

    System.out.println();
}

输出：

abc
b
c

(?<=\\()  // match after an opening parenthesis
[a-z]{2,} // match two or more letters
(?=\\))   // match before closing parenthesis
|         // or
[a-z]     // match a single letter

Test: (ab)(bc)(ca)
   Part: ab
   Part: bc
   Part: ca

Test: abc
   Part: a
   Part: b
   Part: c

Test: (abc)b c
   Part: abc
   Part: b
   Part: c

Test: a (bb) c
   Part: a
   Part: bb
   Part: c

Test: (ab)(bc)(ca)       Parts: [ab, bc, ca]
Test: abc                Parts: [a, b, c]
Test: (abc)b c           Parts: [abc, b, c]
Test: a (bb) c           Parts: [a, bb, c]


类似的事情甚至可能会发生（我可能利用了你的例子中的一个属性，而这个属性在你的“真实”问题中并不存在。我讨厌人们对我的问题这样做，所以如果是这样的话，我提前道歉！）：

您可以在上拆分）（“然后对数组中返回的每个段执行模式匹配。您还必须剥离前导和尾随的“（）”s。您可以在上拆分”）（“然后对数组中返回的每个段执行模式匹配。您还必须剥离前导和尾随的“（）”s。