import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

import static java.lang.System.out;

public class Main {

    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("text.txt"))) {
            printDictionary("words",
                    reader.lines()
                            .filter(line -> !line.isEmpty())
                            .flatMap(line -> Arrays.stream(line.split(WORD_DELIMITERS_REGEX)))
                            .filter(word -> !word.isEmpty())
                            .map(String::toLowerCase)
                            .collect(
                                    Collectors.toMap(
                                            word -> word,
                                            word -> 1,
                                            (count1, count2) -> count1 + count2
                                    )
                            )
            );
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

            Map<String, Integer> dictionary = new HashMap<>();
            for (String line: Files.readAllLines(Paths.get("text.txt"))) {
                if (!line.isEmpty()) {
                    for (String token : line.split(WORD_DELIMITERS_REGEX)) {
                        if (!token.isEmpty()) {
                            token = token.toLowerCase();
                            dictionary.put(token, dictionary.getOrDefault(token, 1));
                        }
                    }
                }
            }

                Stream<String> fileLines = Files.lines(Paths.get("text.txt")); // for line: Files.readAllLines
                Stream<String> notEmptyLines = fileLines.filter(s -> !s.isEmpty()); // if (!line.isEmpty()) {
                Stream<String> allTokens = notEmptyLines.flatMap((String s) -> Arrays.stream(s.split(WORD_DELIMITERS_REGEX)));// for token: line.split
                Stream<String> notEmptyTokens = allTokens.filter(s -> !s.isEmpty()); // if !token.isEmpty
                Stream<String> lowercasedTokens = notEmptyTokens.map(String::toLowerCase); // token = token.toLowerCase()
                Map<String, Integer> dictionary = lowercasedTokens.collect( // dictionary = new HashMap<>()
                        Collectors.toMap(k -> (String) k, k -> 1, (Integer v1, Integer v2) -> v1 + v2) // dictionary.put
                );