Wie erstelle ich einen Stream von regex-matches?

Ich versuche zu analysieren standard-input und extrahieren Sie alle Strings, die übereinstimmungen mit einem bestimmten Muster, zählen Sie die Anzahl der vorkommen jedes Spiel, und drucken Sie die Ergebnisse alphabetisch. Dieses problem scheint, wie ein gutes match für die Streams-API, aber ich kann nicht finden, einen prägnanten Weg, um erstellen Sie einen stream der Spiele von einem Matcher.

Ich arbeitete um dieses problem durch die Implementierung eines iterator über die Spiele und wickeln Sie es in ein Stream, aber das Ergebnis ist nicht sehr gut lesbar ist. Wie kann ich einen stream erstellen, der der regex entspricht, ohne die Einführung zusätzlicher Klassen?

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);
        });
    }
}
InformationsquelleAutor Alfredo Diaz | 2015-01-26
  1. 28

    Gut, in Java 8, es ist - Muster.splitAsStream, die einen stream von Elementen aufgeteilt Trennzeichen Muster, aber leider keine Unterstützung-Methode für immer ein Strom von entspricht.

    Wenn Sie gehen, um die Implementierung einer solchen Stream empfehle ich die Umsetzung Spliterator direkt, sondern Implementierung und die Verpackung eines Iterator. Sie können mehr vertraut mit Iterator aber die Implementierung einer einfachen Spliterator ist straight-forward:

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

    Können Sie prüfen, überschreiben forEachRemaining mit einer straight-forward-Schleife, obwohl.

    Wenn ich verstehe Ihren Versuch, korrekt sollte die Lösung Aussehen:

    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 stellt eine Methode Stream<MatchResult> Ergebnisse() direkt auf die Matcher. Aber für die Suche nach übereinstimmungen innerhalb eines stream, es gibt eine bequemere Methode Scanner. Mit, dass, die Umsetzung vereinfacht

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

    Diese Antwort mit einer "zurück" -port des Scanner.findAll verwendet werden kann, die mit Java 8.

    • Sie können die nicht-NULL-Charakteristik, wie gut. Ich bin mir nicht sicher, ob Sie hinzufügen können, UNVERÄNDERLICH sind oder nicht; die Matcher-Dokumentation ist nicht klar, ob das ändern der zugrunde liegenden CharSequence-Objekt (das kann StringBuilder), während die match-Ergebnisse in definierten Verhalten.
    • in der Tat NONNULL ist möglich IMMUTABLE angegeben werden kann, wenn die Quelle ein String und Sie haben die volle Kontrolle über die Matcher als Matcher's Eigenschaften dürfen nicht geändert werden, wie gut (vor allem der Quelle), aber die Angabe dieser flags ist nicht so wichtig wie derzeit, niemand nutzt diese Flaggen...
    • "leider keine Unterstützung-Methode für immer ein stream der Spiele." Ich habe nie verstanden, diese Lücke zu schließen. Die Java Designer haben müssen, etwas gegen diese, aber wer weiß, was es ist. Aufteilen ist nicht das gleiche, als leer-strings in den Beginn des matches-array sind Häufig. Seufz.
    • Toal: es wird in Java 9...
    • Das ist eine gute Nachricht!
    • sieht aus wie der Java-9-URI geändert hat
    • Ich integrierte Sie in die Antwort, so ist es leichter zu finden. Kommentare können nicht aktualisiert werden, nach einer so langen Zeit, leider.
    • Vielen Dank, ich finde es unglaublich klar und nützlich !
    • Die URL hat sich wieder verändert. Sie zog es hier.
    • das ist die, die ich bearbeitet habe, in meiner Antwort 1½ Jahren...

    InformationsquelleAutor Holger
  2. 4

    Geht aus von Holger ' s Lösung, die wir unterstützen können beliebige Matcher Operationen (wie die nth-Gruppe), indem der Benutzer eine Function<Matcher, String> Betrieb. Wir können auch ausblenden, die Spliterator als eine Implementierung detail, so dass Anrufer nur die Arbeit mit den Stream direkt. Als Faustregel gilt: StreamSupport verwendet werden soll, indem Sie den Bibliotheks-code, anstatt die Benutzer.

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

    Dann können Sie es gerne so:

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

    Oder für Ihre spezielle Aufgabe ("borrowing wieder von 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));
}
    • besser, Sie einfach machen es zu einem Stream<MatchResult> denke ich. Sie nicht zulassen möchten, dass Funktionen, die mutieren, die Match, und dann ordnen Sie es zu einem Stream<String> zu befriedigen OP mit Stream::map
    • auch finde() sollte akzeptieren, CharSequence parameter, nicht nur Strings
    • gute Vorschläge, ich hatte nicht bemerkt MatchResult.
    InformationsquelleAutor dimo414
  3. 0

    Wenn Sie möchten, verwenden Sie eine Scanner zusammen mit regulären Ausdrücken mit der findWithinHorizon Methode könnte man auch konvertieren einen regulären Ausdruck in einen stream von strings.
    Hier verwenden wir einen Strom-generator, die sehr bequem ist zu verwenden bei einer konventionellen while Schleife.

    Hier ist ein Beispiel:

    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();
}
    InformationsquelleAutor gil.fernandes
Schreibe einen Kommentar