Я хочу преобразовать пары чисел в диапазон целых чисел, чтобы я мог выполнять с ними функции. например, каждая из этих строк:

1-4
5-6
1-2
4-7

Должен быть преобразован в массив, например: [1,2,3,4]. Моя цель - подсчитать наиболее частое число. Я пытаюсь сделать это, как пример подсчета слов, но проблема в том, как создать поток диапазона из двух чисел в каждой строке?

Path path = Paths.get(args[0]);
    Map<String, Long> wordCount = Files.lines(path)
            .flatMap(line -> Arrays.stream(line.trim().split("-")))
            .
            .map(word -> word.replaceAll("[^a-zA-Z]", "").toLowerCase().trim())
            .filter(num -> num.length() > 0)
            .map(number -> new SimpleEntry<>(number, 1))
            .collect(Collectors.groupingBy(SimpleEntry::getKey, Collectors.counting()));
6
user1450410 20 Сен 2018 в 20:43

2 ответа

Лучший ответ

Следующий конвейер разбивает каждую строку на -, а затем использует IntStream для создания диапазона чисел между ними.

Результатом является плоский поток всех этих внутренних целых чисел, за которым следует счетная группа по (число). Максимальное «количество» затем находится в значениях этой карты.

String s = "1-4\n" + "5-6\n" + "1-2\n" + "4-7"; //simpler version with inline text

Optional<Entry<Integer, Long>> result = 
    Stream.of(s.split("\n")) //replace with Files.lines(path) for real stream
    .map(line -> line.split("-"))
    .map(array -> new int[] { Integer.parseInt(array[0].trim()), 
                              Integer.parseInt(array[1].trim()) })
    .map(array -> IntStream.rangeClosed(array[0], array[1]))
    .flatMapToInt(Function.identity())
    .boxed()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
    .entrySet()
    .stream()
    .max(Comparator.comparingLong(Entry::getValue));

result.ifPresent(System.out::println);

С данными вашего примера он печатает 1=2 (1 найдено 2 раза) - много значений найдено ровно дважды.

4
ernest_k 20 Сен 2018 в 18:19

Если вы хотите видеть все числа с максимальной частотой, это можно сделать следующим образом:

private static List<Integer> findMaxOccurs(String... ranges) {
    return Optional
        .ofNullable(
            Arrays.stream(ranges)
                  .map(r -> r.split("-"))
                  .flatMap(r -> IntStream.rangeClosed(Integer.parseInt(r[0]),
                                                      Integer.parseInt(r[1]))
                                         .boxed())
                  .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                  // We now have Map<Integer, Long> mapping Number to Frequency
                  .entrySet()
                  .stream()
                  .collect(Collectors.groupingBy(Entry::getValue, TreeMap::new,
                              Collectors.mapping(Entry::getKey, Collectors.toList())))
                  // We now have TreeMap<Long, List<Integer>> mapping Frequency to Numbers
                  .lastEntry()
        )
        .map(Entry::getValue)
        .orElse(Collections.emptyList());
}

< EM> Тест

System.out.println(findMaxOccurs("1-4", "5-6", "1-2", "4-7"));

< EM> Выход

[1, 2, 4, 5, 6]

Если вы также можете узнать частоту этих чисел, было бы лучше разделить это на два метода:

private static Entry<Long, List<Integer>> findMaxOccurring(String... ranges) {
    return Arrays.stream(ranges)
                 .map(r -> r.split("-"))
                 .flatMap(r -> IntStream.rangeClosed(Integer.parseInt(r[0]),
                                                     Integer.parseInt(r[1])).boxed())
                 .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                 // We now have Map<Integer, Long> mapping Number to Frequency
                 .entrySet()
                 .stream()
                 .collect(Collectors.groupingBy(Entry::getValue, TreeMap::new,
                             Collectors.mapping(Entry::getKey, Collectors.toList())))
                 // We now have TreeMap<Long, List<Integer>> mapping Frequency to Numbers
                 .lastEntry();
}
private static List<Integer> findMaxOccurringNumbers(String... ranges) {
    return Optional.ofNullable(findMaxOccurring(ranges))
                   .map(Entry::getValue)
                   .orElse(Collections.emptyList());
}

< EM> Тест

System.out.println(findMaxOccurring("1-4", "5-6", "1-2", "4-7"));
System.out.println(findMaxOccurringNumbers("1-4", "5-6", "1-2", "4-7"));

< EM> Выход

2=[1, 2, 4, 5, 6]
[1, 2, 4, 5, 6]
0
Andreas 20 Сен 2018 в 18:57