Java-关于使用的帮助；拆分（）；

我试图用java编写一段代码，其功能类似于java中的“split（）”命令，但不删除与正则表达式匹配的部分。例如：

String str = "ABC---DEF***GHI///JKL#@!"; 

然后

但是，我想编写一个类似于

split（）

的方法，在正则表达式的匹配处而不是在其周围拆分字符串

`An example of an implementaion would be: 
public static String[] splitString(String input, String regex)` 

因此：

`splitString("ABC---123DEF***456GHI///JKL9#@6!", "[A-Za-z0-9]+")` 

将提供：

`{"ABC", "---", "123DEF", "***", "456GHI", "///", "JKL9", "#@", "6", "!"}` 

---

由于regexp组是有限的，我认为唯一的方法是按您的_模式和ANTY-your_模式进行分割，并按1:1连接结果，如下所示：

ANTY regex为您提供了

[^A-Za-z0-9]+

。（^在[]的开头否定int）

public String[]splitString（字符串输入、字符串正则表达式、字符串反正则表达式）
{
String[]字母=input.split（regex）；
String[]symbols=input.split（antiRegex）；
字符串[]结果=新字符串[字母.length+符号.length]；
for（int i=0；i

---

UPD：没有检查lettess序列是否位于输入字符串的第一位，因此如果需要，请添加id。

您可以编写一个方法，使用正则表达式并从原始字符串中删除第一个找到的匹配项。我有点懒得写整个代码，但在伪代码中，它会是这样的。您将使用两种模式—一种用于单词，另一种用于字符串开头的所有其他模式：

Pattern literals="(^[A-Za-z0-9]+)";
Pattern everythingElse="(^[^A-Za-z0-9]+)";
List<String> results;

while(str is not finished){
 Matcher literalsMatcher= literals.matcher(str);
 if(literalsMatcher.find()){
   results.add(literalsMatcher.group(1));
   str.subString(0,literalsMatcher.group(1).length();
 }

Matcher everythingElseMatcher = everythingElse.matcher(str);
 if(everythingElseMatcher.find()){
   results.add(everythingElseMatcher.group(1));
   str.subString(0,everythingElseMatcher.group(1).length();
 }

Pattern literals=“（^[A-Za-z0-9]+）”；
模式everythingElse=“（^[^A-Za-z0-9]+）”；
列出结果；
while（str未完成）{
Matcher literalsMatcher=文本。Matcher（str）；
if（literalsMatcher.find（））{
结果：添加（literalsMatcher.组（1））；
str.subString（0，literalsMatcher.group（1）.length（）；
}
Matcher everythingElseMatcher=everythingElse.Matcher（str）；
if（everythingElseMatcher.find（））{
结果：添加（所有匹配器组（1））；
str.subString（0，everythingElseMatcher.group（1.length））；
}

}

---

诸如此类。很抱歉代码不好，但我认为您可以理解。

使用匹配器查找正则表达式的所有匹配项，然后自己生成拆分结果

以下方法显示正则表达式的所有匹配项的位置：

public static void findMatches(String input, String regex)
{
    Matcher matcher = Pattern.compile(regex).matcher(input);

    while (matcher.find()) {
        System.out.printf("%d-%d%n", matcher.start(), matcher.end());
    }
}

---

现在，用这种方法找到的索引与

String.substring（beginIndex，endIndex）

一起创建具有所需拆分结果的字符串数组。

正如其他海报所指出的，一种方法是使用模式，然后使用相反的模式。这可以通过单个正则表达式

（[a-Za-z0-9]*）（[^a-Za-z0-9]*）来完成

---

这里有一个循环版本：

  public static String[] split(String msg, String expr){
      if (msg.split(expr).length == 1){
        return msg.split(expr);
      }
      String[] tab = msg.split(expr, 2);
      String exprStr = msg.substring(tab[0].length(),  msg.length() -  tab[1].length());
      int exprLength = msg.length() - tab[0].length() - tab[1].length();
      String[] tab1 = split(msg.substring(tab[0].length() + exprLength, msg.length()), expr);
      String[] result = new String[1 + 1 + tab1.length];
      result[0] = tab[0];
      result[1] = exprStr;
      for (int i = 0; i <  tab1.length;++i){
         result[i + 2] = tab1[i];
      }
      return result;

publicstaticstring[]split（stringmsg，stringexpr）{
if（msg.split（expr.length==1）{
返回消息拆分（expr）；
}
String[]tab=msg.split（expr，2）；
字符串exprStr=msg.substring（tab[0].length（），msg.length（）-tab[1].length（））；
int exprllength=msg.length（）-tab[0]。length（）-tab[1]。length（）；
String[]tab1=split（msg.substring（tab[0].length（）+exprllength，msg.length（）），expr）；
字符串[]结果=新字符串[1+1+tab1.length]；
结果[0]=制表符[0]；
结果[1]=exprStr；
对于（int i=0；i

---

}

到目前为止，您编写了什么？因此您希望在结果中同时包含这两种结果，即分割结果+匹配模式？请努力为您编写代码。请向我们展示预期的输出？值得一提的是，在其他语言中，您只需使用

.split（[a-Za-z0-9]+）

（带有捕获组），但Java缺少此功能。这实际上是一个比使用倒正则表达式（包括我的）更好的解决方案。您应该修改正则表达式，使其与“+++ABC----…”（+1）的情况相匹配

public static void findMatches(String input, String regex)
{
    Matcher matcher = Pattern.compile(regex).matcher(input);

    while (matcher.find()) {
        System.out.printf("%d-%d%n", matcher.start(), matcher.end());
    }
}

String str = "ABC---DEF***GHI///JKL#@!";
Matcher m = Pattern.compile("([A-Za-z0-9]*)([^A-Za-z0-9]*)").matcher(str);
List<String> result = new ArrayList<>();
while(m.find()) {
    for(int i=1; i<=m.groupCount(); i++) {
        if(!m.group(i).isEmpty()) {
            result.add(m.group(i));
        }
    }
}
System.out.println(StringUtils.join(result, ", "));

ABC, ---, 123DEF, ***, 456GHI, ///, JKL9, #@, 6, !

  public static String[] split(String msg, String expr){
      if (msg.split(expr).length == 1){
        return msg.split(expr);
      }
      String[] tab = msg.split(expr, 2);
      String exprStr = msg.substring(tab[0].length(),  msg.length() -  tab[1].length());
      int exprLength = msg.length() - tab[0].length() - tab[1].length();
      String[] tab1 = split(msg.substring(tab[0].length() + exprLength, msg.length()), expr);
      String[] result = new String[1 + 1 + tab1.length];
      result[0] = tab[0];
      result[1] = exprStr;
      for (int i = 0; i <  tab1.length;++i){
         result[i + 2] = tab1[i];
      }
      return result;