Question

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

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

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);
        });
    }
}

Answer 1

好吧，在Java 8中，Pattern.splitAsStream将提供由分隔符模式拆分的项目流，但遗憾的是没有获取匹配流的支持方法< / em>的

如果您要实现此类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直接在Matcher上提供了方法Stream<MatchResult> results()。但是为了在流中找到匹配，有an even more convenient method on 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)); }

This answer包含一个可以与Java 8一起使用的Scanner.findAll的后端。

Answer 2

离开Holger的解决方案，我们可以通过让用户提供Matcher操作来支持任意Function<Matcher, String>操作（例如获取 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));
}

Answer 3

如果要使用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();
}

如何创建正则表达式匹配流？

3 个答案: