import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import static java.lang.System.out;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.Collector;

public class Main
{
    public static final String WORD_DELIMITERS_REGEX = "[ \\t,.?!:;\"()\\[\\]«»…]+";

    static void printDictionary(String name, Map<String, Integer> c)
    {
        if (c.isEmpty())
            out.printf("Dictionary '%s' is empty.\n", name);
        else
        {
            Iterator<String> i = c.keySet().iterator();
            out.printf("Dictionary '%s':\n", name);
            while (i.hasNext())
            {
                String k = i.next();
                out.printf("\t%s[%s] == %d\n", name, k, c.get(k));
            }
        }
    }

    public static void main(String[] args)
    {
        try
        {
            //Map<String, Integer> words =
            printDictionary( "words",
                    Files.lines(Paths.get("text.txt"))
                    .filter( s -> !s.isEmpty() )
                    .flatMap( (String s) -> Arrays.stream( s.split(WORD_DELIMITERS_REGEX) ) )
                    .filter( s -> !s.isEmpty() )
                    .map( String::toLowerCase )
                    .collect(
                            Collectors.toMap(
                                                k -> (String)k,
                                                k -> new Integer(1),
                                                (Integer v1, Integer v2) -> new Integer( v1.intValue() + v2.intValue() )
                                            )
                            )
            );
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

    }
}

import static java.lang.System.out;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static final String WORD_DELIMITERS_REGEX = "[ \\t,.?!:;\"()\\[\\]«»…]+";
    static final ArrayList<String> nonWords = new ArrayList<>( Arrays.asList("-", "–") );

    static void printDictionary(String name, Map<?, ?> c) // функция не используется.
    {
        out.printf( c.isEmpty() ? "Dictionary '%s' is empty.\n" : "Dictionary '%s':\n", name);
        c.forEach( (k,v) -> out.printf("\t%s[%s] == %d\n", name, k, v ) );
    }

    static void printDictionarySortedByValue(String name, Map<?, Integer> c)
    {
        out.printf( c.isEmpty() ? "Dictionary '%s' is empty.\n" : "Dictionary '%s':\n", name);
        c.entrySet()
         .stream()
         .sorted( (e1, e2) -> e2.getValue()-e1.getValue() )
         .forEach( e -> out.printf("\t%s[%s] == %d\n", name, e.getKey(), e.getValue() ) );
    }

    public static void main(String[] args)
    {
        try
        {
            //Map<String, Integer>
            printDictionarySortedByValue( "words",
                    Files.lines(Paths.get("text.txt"))
                    .flatMap( s -> Arrays.stream( s.split(WORD_DELIMITERS_REGEX) ) )
                    .filter( s -> !s.isEmpty() && !nonWords.contains(s) )
                    .map( String::toLowerCase )
                    .collect( Collectors.toMap( k -> k, k -> 1, (v1, v2) -> v1 + v2 ) )
            );
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

static final List<String> nonWords = Arrays.asList("-", "–");

import static java.lang.System.out;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class Main
{
    static final String WORD_DELIMITERS_REGEX = "[\\s \\t,.?!:;\"()\\[\\]«»…]+";
    static final ArrayList<String> nonWords = new ArrayList<>( Arrays.asList("-", "–") );

    static void printDictionary(String name, Map<?, ?> c)
    {
        out.printf( c.isEmpty() ? "Dictionary '%s' is empty.\n" : "Dictionary '%s':\n", name);
        c.forEach( (k,v) -> out.printf("\t%s[%s] == %d\n", name, k, v ) );
    }

    static void printDictionarySortedByValue(String name, Map<?, Integer> c)
    {
        out.printf( c.isEmpty() ? "Dictionary '%s' is empty.\n" : "Dictionary '%s':\n", name);
        if( !c.isEmpty() )
            out.printf( "distinct words %d, total words %d\n", c.size(), c.values().stream().reduce( (c1, c2) -> c1 + c2 ).orElse(0) );
        c.entrySet().stream().sorted( (e1, e2) -> e2.getValue()-e1.getValue() )
                .forEach( e -> out.printf("\t%s[%s] = %d\n", name, e.getKey(), e.getValue() ) );
    }

    public static void main(String[] args)
    {
        try(InputStream is = new FileInputStream(args[0]);
            Scanner sc = new Scanner(is).useDelimiter(WORD_DELIMITERS_REGEX);
            Stream<String> word_stream = StreamSupport.stream( Spliterators.spliterator(sc, 1, 0), false)
            )
        {
            Map<String, Integer> words = word_stream.filter( s -> !s.isEmpty() && !nonWords.contains(s) )
                                                    .map( String::toLowerCase )
                                                    .collect( Collectors.toMap( k -> k, k -> 1, (v1, v2) -> v1 + v2 ) );
            printDictionarySortedByValue( "words", words );
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

public class Main