//TestHashMapOfStringAndHashSetOfInteger.java
//Obtained from TestTreeMapOfStringAndTreeSetOfInteger.java
//simply by replacing each instance of TreeMap with HashMap
//and each instance of TreeSet with HashSet.

import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

public class TestHashMapOfStringAndHashSetOfInteger
{
    public static void main(String[] args)
    {
        System.out.println("=====1=========================");
        //Create empty String/HashSet of Integer HashMap, then
        //display content and size.
        HashMap<String, HashSet<Integer>> hashMap;
        hashMap = new HashMap<String, HashSet<Integer>>();
        System.out.println(hashMap);
        System.out.println(hashMap.size());
        pause(1);

        System.out.println("=====2=========================");
        //Create an empty HashSet of Integer and display its content and size.
        HashSet<Integer> hashSetInt;
        hashSetInt = new HashSet<Integer>();
        System.out.println(hashSetInt);
        System.out.println(hashSetInt.size());
        pause(2);

        System.out.println("=====3=========================");
        //Put two integers into the empty HashSet and re-display.
        hashSetInt.add(2);
        hashSetInt.add(5);
        System.out.println(hashSetInt);
        System.out.println(hashSetInt.size());
        pause(3);

        System.out.println("=====4=========================");
        //Put a key/value pair into the HashMap and display.
        hashMap.put("Hello", hashSetInt);
        System.out.println(hashMap);
        System.out.println(hashMap.size());
        System.out.println(hashMap.get("Hello"));
        System.out.println(hashMap.get("Hello").size());
        pause(4);

        System.out.println("=====5=========================");
        //This code segment has no effect because the value set already
        //contains the single value to be added.
        if (hashMap.containsKey("Hello"))
        {
            hashMap.get("Hello").add(5);
        }
        else
        {
            hashSetInt = new HashSet<Integer>();
            hashSetInt.add(5);
            hashMap.put("Hello", hashSetInt);
        }
        System.out.println(hashMap);
        System.out.println(hashMap.size());
        System.out.println(hashMap.get("Hello"));
        System.out.println(hashMap.get("Hello").size());
        pause(5);

        System.out.println("=====6=========================");
        //This code segment does take effect because the value set
        //does not already contain the single value to be added.
        if (hashMap.containsKey("Hello"))
        {
            hashMap.get("Hello").add(12);
        }
        else
        {
            hashSetInt = new HashSet<Integer>();
            hashSetInt.add(12);
            hashMap.put("Hello", hashSetInt);
        }
        System.out.println(hashMap);
        System.out.println(hashMap.size());
        System.out.println(hashMap.get("Hello"));
        System.out.println(hashMap.get("Hello").size());
        pause(6);

        System.out.println("=====7=========================");
        //Add a new key/value pair to the HashMap and re-display.
        if (hashMap.containsKey("Good-bye"))
        {
            hashMap.get("Good-bye").add(20);
        }
        else
        {
            hashSetInt = new HashSet<Integer>();
            hashSetInt.add(20);
            hashMap.put("Good-bye", hashSetInt);
        }
        System.out.println(hashMap);
        System.out.println(hashMap.size());
        System.out.println(hashMap.get("Hello"));
        System.out.println(hashMap.get("Hello").size());
        System.out.println(hashMap.get("Good-bye"));
        System.out.println(hashMap.get("Good-bye").size());
        pause(7);

        System.out.println("=====8=========================");
        //Display all keys, all values and all key/value pairs.
        //Do it first the pre-Java 8 way ...
        for (String s : hashMap.keySet())
        {
            System.out.print(s + " ");
        }
        System.out.println();
        for (HashSet<Integer> hashSet : hashMap.values())
        {
            System.out.print(hashSet + " ");
        }
        System.out.println();
        for (String s : hashMap.keySet())
        {
            System.out.println(s + " " + hashMap.get(s));
        }
        pause(8);

        System.out.println("=====9=========================");
        //Display all keys, all values and all key/value pairs.
        //Now do it the Java 8 way ...
        hashMap.keySet().forEach(s -> System.out.print(s + " "));
        System.out.println();
        hashMap.values().forEach(i -> System.out.print(i + " "));
        System.out.println();
        hashMap.keySet().forEach
        (
            s -> System.out.println(s + " " + hashMap.get(s))
        );
        pause(9);
    }

    public static void pause(int pauseNumber)
    {
        Scanner keyboard = new Scanner(System.in);
        System.out.println("Pause " + pauseNumber);
        System.out.print("Press Enter to continue ... ");
        keyboard.nextLine();
    }
}
/*  Output (without the pauses):
    =====1=========================
    {}
    0
    =====2=========================
    []
    0
    =====3=========================
    [2, 5]
    2
    =====4=========================
    {Hello=[2, 5]}
    1
    [2, 5]
    2
    =====5=========================
    {Hello=[2, 5]}
    1
    [2, 5]
    2
    =====6=========================
    {Hello=[2, 5, 12]}
    1
    [2, 5, 12]
    3
    =====7=========================
    {Hello=[2, 5, 12], Good-bye=[20]}
    2
    [2, 5, 12]
    3
    [20]
    1
    =====8=========================
    Hello Good-bye
    [2, 5, 12] [20]
    Hello [2, 5, 12]
    Good-bye [20]
    =====9=========================
    Hello Good-bye
    [2, 5, 12] [20]
    Hello [2, 5, 12]
    Good-bye [20]
*/