我该如何创建一个正则表达式匹配结果的流？

Question

我该如何创建一个正则表达式匹配结果的流？

33

我正在尝试解析标准输入并提取与特定模式匹配的每个字符串，计算每个匹配项出现的次数，并按字母顺序打印结果。这个问题似乎很适合使用流API，但我找不到一种简洁的方法来从Matcher创建匹配流。

我通过实现一个迭代器来解决这个问题，并将其包装成一个流，但结果不是很易读。如何在不引入其他类的情况下创建正则表达式匹配流？

public class PatternCounter
{
    static private class MatcherIterator implements Iterator<String> {
        private final Matcher matcher;
        public MatcherIterator(Matcher matcher) {
            this.matcher = matcher;
        }
        public boolean hasNext() {
            return matcher.find();
        }
        public String next() {
            return matcher.group(0);
        }
    }

    static public void main(String[] args) throws Throwable {
        Pattern pattern = Pattern.compile("[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)");

        new TreeMap<String, Long>(new BufferedReader(new InputStreamReader(System.in))
            .lines().map(line -> {
                Matcher matcher = pattern.matcher(line);
                return StreamSupport.stream(
                        Spliterators.spliteratorUnknownSize(new MatcherIterator(matcher), Spliterator.ORDERED), false);
            }).reduce(Stream.empty(), Stream::concat).collect(groupingBy(o -> o, counting()))
        ).forEach((k, v) -> {
            System.out.printf("%s\t%s\n",k,v);
        });
    }
}

- Alfredo Diaz

9

在Java 9中，将会有一个名为Matcher.results的方法。请参见 http://download.java.net/jdk9/docs/api/java/util/regex/Matcher.html#results-- - user140547

2

似乎Java 9的URI已更改。 - Gary

3个回答

4

参考Holger的解决方案，我们可以通过让用户提供一个Function<Matcher, String>操作来支持任意的Matcher操作（例如获取第n组）。我们还可以将Spliterator隐藏为实现细节，以便调用者可以直接使用Stream。作为经验法则，应该由库代码使用StreamSupport，而不是用户。

public class MatcherStream {
  private MatcherStream() {}

  public static Stream<String> find(Pattern pattern, CharSequence input) {
    return findMatches(pattern, input).map(MatchResult::group);
  }

  public static Stream<MatchResult> findMatches(
      Pattern pattern, CharSequence input) {
    Matcher matcher = pattern.matcher(input);

    Spliterator<MatchResult> spliterator = new Spliterators.AbstractSpliterator<MatchResult>(
        Long.MAX_VALUE, Spliterator.ORDERED|Spliterator.NONNULL) {
      @Override
      public boolean tryAdvance(Consumer<? super MatchResult> action) {
        if(!matcher.find()) return false;
        action.accept(matcher.toMatchResult());
        return true;
      }};

    return StreamSupport.stream(spliterator, false);
  }
}

您可以像这样使用它：

MatcherStream.find(Pattern.compile("\\w+"), "foo bar baz").forEach(System.out::println);

或者针对您的特定任务（再次借鉴Holger的话）：

try(BufferedReader br = new BufferedReader(System.console().reader())) {
  br.lines()
    .flatMap(line -> MatcherStream.find(pattern, line))
    .collect(Collectors.groupingBy(o->o, TreeMap::new, Collectors.counting()))
    .forEach((k, v) -> System.out.printf("%s\t%s\n", k, v));
}

- dimo414

1

我认为最好只需将其制作成Stream<MatchResult>。您不希望允许修改Match的函数，然后您可以使用Stream::map将其映射到Stream<String>以满足OP的要求。 - Patrick Parker

1

另外，find() 应该接受 CharSequence 参数，而不仅仅是 String。 - Patrick Parker

@PatrickParker 的建议很好，我之前没有注意到 MatchResult。 - dimo414

2

如果您想使用Scanner结合正则表达式使用findWithinHorizon方法，您也可以将正则表达式转换为字符串流。在这里，我们使用一个非常方便的流构建器，在传统的while循环中使用它非常方便。

以下是一个示例：

private Stream<String> extractRulesFrom(String text, Pattern pattern, int group) {
    Stream.Builder<String> builder = Stream.builder();
    try(Scanner scanner = new Scanner(text)) {
        while (scanner.findWithinHorizon(pattern, 0) != null) {
            builder.accept(scanner.match().group(group));
        }
    }
    return builder.build();
}

- gil.fernandes

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Holger · Accepted Answer

在Java 8中，有Pattern.splitAsStream函数可以根据分隔符模式提供一个项目流，但不幸的是没有支持获取匹配项流的方法。

如果你要实现这样的Stream，我建议直接实现Spliterator而不是实现和包装Iterator。你可能更熟悉Iterator，但实现一个简单的Spliterator很简单：

final class MatchItr extends Spliterators.AbstractSpliterator<String> {
    private final Matcher matcher;
    MatchItr(Matcher m) {
        super(m.regionEnd()-m.regionStart(), ORDERED|NONNULL);
        matcher=m;
    }
    public boolean tryAdvance(Consumer<? super String> action) {
        if(!matcher.find()) return false;
        action.accept(matcher.group());
        return true;
    }
}

你可以考虑使用直接的循环覆盖forEachRemaining，不过。

如果我正确理解了您的尝试，解决方案应该更像是：

Pattern pattern = Pattern.compile(
                 "[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)");

try(BufferedReader br=new BufferedReader(System.console().reader())) {

    br.lines()
      .flatMap(line -> StreamSupport.stream(new MatchItr(pattern.matcher(line)), false))
      .collect(Collectors.groupingBy(o->o, TreeMap::new, Collectors.counting()))
      .forEach((k, v) -> System.out.printf("%s\t%s\n",k,v));
}

Java 9提供了一个方法Stream<MatchResult> results()，直接在Matcher上使用。但是，为了在流中查找匹配项，Scanner上有更方便的方法。通过这种方式，实现变得更加简单。

try(Scanner s = new Scanner(System.console().reader())) {
    s.findAll(pattern)
     .collect(Collectors.groupingBy(MatchResult::group,TreeMap::new,Collectors.counting()))
     .forEach((k, v) -> System.out.printf("%s\t%s\n",k,v));
}

这个答案包含了一个可用于 Java 8 的 Scanner.findAll 的回溯端口。