如何創建正則表達式匹配流？

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 ，它將提供一個由分隔符模式拆分的項目流，但遺憾的是沒有獲取匹配流的支持方法。

如果您要實現這樣的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() 。 但是為了在流中查找匹配， 在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的后端口。

Answer 2

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

Answer 3

如果要使用findWithinHorizon方法將Scanner與正則表達式一起使用，還可以將正則表達式轉換為字符串流。 這里我們使用一個流構建器，它在傳統的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();
}