отдельные номера потока java к диапазону

Question

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

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

Answer 1

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

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

Тест

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

Выход

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

Тест

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

Выход

2=[1, 2, 4, 5, 6]
[1, 2, 4, 5, 6]

Answer 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 раза) - многие значения найдены ровно дважды.