正则表达式分割成重叠的字符串

Question

我正在探索正则表达式的强大功能，所以我只是想知道这样的事情是否可能：

public class StringSplit {
    public static void main(String args[]) {
        System.out.println(
            java.util.Arrays.deepToString(
                "12345".split(INSERT_REGEX_HERE)
            )
        ); // prints "[12, 23, 34, 45]"
    }
}

如果可能，则只需提供正则表达式（并预先解释其工作原理）。

如果它只能在 Java 之外的某些正则表达式风格中实现，那么也可以随意提供这些。

如果不可能，请解释原因。

---

额外问题

同样的问题，但使用 find() 循环而不是 split：

    Matcher m = Pattern.compile(BONUS_REGEX).matcher("12345");
    while (m.find()) {
        System.out.println(m.group());
    } // prints "12", "23", "34", "45"

---

请注意，这并不是说我有一个具体的任务以一种或另一种方式完成，但我想理解正则表达式。我不需要做我想做的事情的代码；我想要正则表达式（如果存在），我可以在上面的代码中使用它们来完成任务（或者其他风格的正则表达式，可以将代码“直接翻译”为另一种语言）。

如果它们不存在，我想要一个很好的、可靠的解释。

Answer 1

我认为使用 split() 不可能做到这一点，但使用 find() 则非常简单。只需使用内部带有捕获组的前瞻：

Matcher m = Pattern.compile("(?=(\\d\\d)).").matcher("12345");
while (m.find())
{
  System.out.println(m.group(1));
}

许多人没有意识到在前瞻或后视中捕获的文本可以在匹配后引用，就像任何其他捕获一样。在这种情况下，这是特别违反直觉的，因为捕获是“整个”匹配的超集。

事实上，即使整个正则表达式没有匹配任何内容，它也能工作。从上面的正则表达式中删除点 ("(?=(\\d\\d))")，您将得到相同的结果。这是因为，只要成功匹配不消耗任何字符，正则表达式引擎就会在尝试再次匹配之前自动前进一个位置，以防止无限循环。

不过，这种技术没有等效的 split() 方法，至少在 Java 中是这样。尽管您可以对环视和其他零宽度断言进行拆分，但无法使同一字符出现在多个结果子字符串中。

Answer 2

使用 Matcher.find 而不是 split 的这种有点繁重的实现也可以工作，尽管此时您必须为这样的代码编写一个 for 循环。琐碎的任务，你不妨完全放弃正则表达式并使用子字符串（对于类似的编码复杂性减去CPU周期）：

import java.util.*;
import java.util.regex.*;

public class StringSplit { 
    public static void main(String args[]) { 
        ArrayList<String> result = new ArrayList<String>();
        for (Matcher m = Pattern.compile("..").matcher("12345"); m.find(result.isEmpty() ? 0 : m.start() + 1); result.add(m.group()));
        System.out.println( result.toString() ); // prints "[12, 23, 34, 45]" 
    } 
} 

EDIT1

match()：迄今为止没有人能够编造正则的原因像 BONUS_REGEX 这样的表达式位于 Matcher 中，它将继续寻找上一组结束的下一组（即没有重叠），而不是上一组开始的位置之后——也就是说，没有明确地重新指定开始搜索位置（上面）。 BONUS_REGEX 的一个很好的候选者是 "(.\\G.|^..)"，但不幸的是，\G-中间锚技巧不适用于 Java 的 Match（但在 Perl 中工作得很好）：

 perl -e 'while ("12345"=~/(^..|.\G.)/g) { print "$1\n" }'
 12
 23
 34
 45

split()：与 INSERT_REGEX_HERE 一样code> 一个好的候选者是 (?<=..)(?=..) （分割点是零宽度位置，其中我的右侧有两个字符，我的右侧有两个字符左），但同样，因为 split 不会出现任何重叠，所以最终会得到 [12, 3, 45] （很接近，但没有雪茄。）

EDIT2

为了好玩，您可以通过首先将非边界字符加倍来欺骗 split() 来完成您想要的操作（这里您需要一个保留字符值来分割）：

Pattern.compile("((?<=.).(?=.))").matcher("12345").replaceAll("$1#$1").split("#")

我们可以聪明地消除对保留字符的需要通过利用零宽度前瞻断言（与后视不同）可以具有无限长度的事实来改变字符；因此，我们可以围绕距离双倍字符串末尾偶数个字符的所有点（距离其开头至少两个字符）进行分割，产生与上面相同的结果

Pattern.compile("((?<=.).(?=.))").matcher("12345").replaceAll("$1$1").split("(?<=..)(?=(..)*$)")

： match() 以类似的方式（但不需要保留字符值）：

Matcher m = Pattern.compile("..").matcher(
  Pattern.compile("((?<=.).(?=.))").matcher("12345").replaceAll("$1$1")
);
while (m.find()) { 
    System.out.println(m.group()); 
} // prints "12", "23", "34", "45" 

Answer 3

Split 将字符串切成多个部分，但这不允许重叠。您需要使用循环来获得重叠的部分。

Answer 4

我认为你不能用 split() 来做到这一点，因为它会丢弃与正则表达式匹配的部分。

在 Perl 中，这是有效的：

my $string = '12345';
my @array = ();
while ( $string =~ s/(\d(\d))/$2/ ) {
    push(@array, $1);
}
print join(" ", @array);
# prints: 12 23 34 45

查找和替换表达式表示：匹配前两个相邻数字，并仅用这两个数字中的第二个数字替换字符串中的它们。

Answer 5

或者，使用 Perl 的简单匹配。应该在前瞻可以工作的任何地方工作。这里不需要循环。

 $_ = '12345';
 @list = /(?=(..))./g;
 print "@list";

 # Output:
 # 12 23 34 45

但是，如之前发布的，如果 \G 技巧有效，则效果会更好：

 $_ = '12345';
 @list = /^..|.\G./g;
 print "@list";

 # Output:
 # 12 23 34 45

---

编辑：抱歉，没有看到所有内容都已发布。

Answer 6

使用 String#split 是不可能的，正如其他答案已经指出的那样。但是，可以在其之前添加正则表达式替换来准备字符串，然后使用拆分来创建常规对：

"12345".replaceAll(".(?=(.).)","$0$1")
       .split("(?<=\\G..)")

.replaceAll(".(?=(.).)","$0$1" ) 会将 "12345" 转换为 "12233445"。它基本上将每个 123 子字符串替换为 1223，然后将每个 234 替换为 2334（请注意，它是重叠的），等等换句话说，它将复制除第一个和最后一个字符之外的每个字符。

.(?=(.).)  # Replace-regex:
.          #  A single character
 (?=    )  #  followed by (using a positive lookahead):
     . .   #   two more characters
    ( )    #   of which the first is saved in capture group 1

$0$1       # Replacement-regex:
$0         #  The entire match, which is the character itself since everything
           #  else was inside a lookahead
  $1       #  followed by capture group 1

之后， .split("(?<=\\G..)") 会将这个新字符串分成对：

(?<=\G..) # Split-regex:
(?<=    ) #  A positive lookbehind:
    \G    #   Matching the end of the previous match
          #   (or the start of the string initially)
      ..  #   followed by two characters

有关 .split("(?<; =\\G..)") 可以在此处。

在线尝试。