import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    private static boolean checkArgs(String[] args) {

        if (args.length == 0) {
            System.out.println("Передайте путь к существующему файлу");
            return false;
        }

        Path file = Paths.get(args[0]);

        if (Files.notExists(file) || Files.isDirectory(file)) {
            System.out.println("Передайте путь к существующему файлу");
            return false;
        }

        return true;
    }

    private static Comparator<Map.Entry<String, Long>> myComparator() {
        //    вот это нужно чтобы java поняла какие типы у getValue и getKey
        //    |___________________________  ______________________________|
        //                                \/
        return Comparator.<Map.Entry<String, Long>>comparingLong
                 (Map.Entry::getValue) // сравнивает сначала по значению количества
         // перевернем в обратном порядке, чтобы шли по убыванию значения количества
                .reversed() 
         // и в конце пересортируем при равных количествах по алфавиту слова
                .thenComparing(Map.Entry::getKey); 
    }

    public static void main(String[] args) throws IOException {
        if (checkArgs(args)) {
            Path file = Paths.get(args[0]);

            List<String> words = Files.lines(file)
               // получаем массив слов в строке
                    .map(line -> line.split("\\s+")) 
               // меняем массивы слов на один поток слов
                    .flatMap(Arrays::stream) 
               // убираем пустые строки из потока
                    .filter(word -> !word.isEmpty()) 
               // переводим каждое слово в нижний регистр
                    .map(String::toLowerCase) 
     // групируем слова по их имени и считаем с помощью композиции коллекторов 
               //сколько раз слово встретилось
                    .collect(Collectors.groupingBy(Function.identity(), 
                                                            Collectors.counting()))
   // так как на этот момент уже будет Map, то получаем поток пар: слово - количество
                    .entrySet().stream()
               // сортируем пары по нашему правилу
                    .sorted(myComparator()) 
               // берем первые 10 часто встречаемых слов
                    .limit(10) 
               // из потока пар возьмем только ключ (слово)
                    .map(Map.Entry::getKey) 
               // и преобразуем поток к списку
                    .collect(Collectors.toList()); 

            // Выводим ответ к задаче

            System.out.println("Ответ на условие задачи: ");

            if (words.size() == 0) {
                System.out.println("Файл не содержит слов");
                return;
            }

            words.forEach(System.out::println);
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toList;

public class Main {
    public static void main(String[] args) throws IOException {
        // Читаем значение для расчета остатка числа
        BufferedReader bufferedReader = new BufferedReader(
                                                   new InputStreamReader(System.in));
        int n = Integer.parseInt(bufferedReader.readLine());

        // Формируем список произвольных чисел
        Random rnd = new Random();
        List<Integer> list = Stream.generate(() -> rnd.nextInt(200))
                .limit(100)
                .collect(toList());

        // Группируем числа по остаткам
        Map<Integer, List<Integer>> groups = list.stream()
                .collect(groupingBy(x -> x % n));

        groups.entrySet()
                .stream()
                // сортируем по значению остатка
                .sorted(Comparator.comparingInt(Map.Entry::getKey)) 
                .forEach(e -> {
                    // Выводим каждую группу
                    System.out.print(e.getKey() + ":");
                    List<Integer> group = e.getValue();
                    group.forEach(v -> System.out.print(" " + v));
                    System.out.println();
                });
    }
}