Как создать совпадение регулярных выражений?

Я пытаюсь разобрать стандартный ввод и извлекать каждую строку, которая соответствует определенному шаблону, подсчитывать количество вхождений каждого совпадения и печатать результаты в алфавитном порядке. Эта проблема кажется хорошим совпадением для API Streams, но я не могу найти краткий способ создания потока совпадений из 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.!#$%&’*+/=?^_`{|}~-][email protected][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);
        });
    }
}

Ответ 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.!#$%&’*+/=?^_`{|}~-][email protected][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. Но для поиска совпадений в потоке theres еще более удобный метод на 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));
}

Этот ответ содержит обратный порт Scanner.findAll, который можно использовать с Java 8.

Ответ 2

Уходя из решения Холгера, мы можем поддерживать произвольные операции Matcher (например, получение n-й группы), предоставляя пользователю операцию Function<Matcher, String>. Мы также можем скрыть 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);

Или для вашей конкретной задачи (заимствования снова у Хольгера):

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