Demo: word frequency with Map

Written Explanation

The plan

The task: given a sentence, report how many times each word appears. In the language of Lesson 6:

1. We look up and update by word, so the family is Map, from word to count.
2. We do not care about order while counting, so the implementation is HashMap.
3. For a sorted report we can copy into a TreeMap at the end.

Before coding, hand-trace a tiny case, as in BEG-016. For a b a: start empty; see a (count 1); see b (count 1); see a again (count 2). The result is {a=2, b=1}. If the code reproduces this, we trust it on bigger input.

Step 1: split into words

String text = "The cat saw the dog. The dog saw the bird, and the bird saw the cat!";
String[] words = text.toLowerCase().split("[^a-z]+");

toLowerCase() makes The and the the same word. split cuts the string wherever the pattern matches. The pattern [^a-z]+ is a small regular expression that means "one or more characters that are not a lowercase letter", so spaces, commas, periods, and exclamation marks all act as separators. Treat the pattern as something to copy for now; regular expressions are a topic of their own. The pattern keeps only ASCII letters a to z, so it would also split a word containing digits or accented letters, which is acceptable for this demo and worth remembering for real text.

Step 2: count, with the planned mistake first

The natural-looking first attempt is:

Map<String, Integer> counts = new HashMap<>();
for (String w : words) {
    counts.put(w, counts.get(w) + 1);   // planned mistake
}

Run it on a b a. It crashes on the first word with Cannot invoke "java.lang.Integer.intValue()" because the return value of "java.util.Map.get(Object)" is null. The first time we see a, get("a") is null, and adding 1 forces Java to unbox null. This is exactly the missing-key trap from Lesson 4.

Step 3: the fix

Give missing words a starting count of 0:

counts.put(w, counts.getOrDefault(w, 0) + 1);

Equivalent and shorter: counts.merge(w, 1, Integer::sum);. The documentation says merge stores the given value when the key is absent and otherwise combines old and new values with the function you pass. Integer::sum is a method reference, a preview of BEG-035: read it as "add the two numbers". Both forms give the same counts; we use getOrDefault here because every piece of it is already familiar.

Step 4: the second planned mistake, the empty word

If the text starts with a separator, split produces an empty string as the first element. The demo text begins with two spaces, so words.length is 17, not 16, and words[0] is "". The empty string would be counted as a "word". Guard against it:

if (w.isEmpty()) continue;

continue skips to the next loop iteration, as in BEG-013-L04.

Step 5: sorted output

A HashMap prints in no promised order. To see the counts alphabetically, copy them into a TreeMap:

Map<String, Integer> sorted = new TreeMap<>(counts);

This works because a TreeMap keeps its keys in sorted order (Lesson 4) and has a constructor that copies from another map. Alternatively, count into a TreeMap from the start, which costs a little more per update.

Step 6: the top three, without sorting tools

Sorting entries by value needs comparators and lambdas, which come in BEG-032 and BEG-035. For now we can do it with what we know, borrowing the selection idea from BEG-017-L05: repeatedly find the entry with the highest count, report it, and remove it from a copy of the map. We copy so the original counts survive.

Map<String, Integer> copy = new HashMap<>(counts);
for (int rank = 1; rank <= 3 && !copy.isEmpty(); rank++) {
    String best = null;
    for (Map.Entry<String, Integer> e : copy.entrySet()) {
        if (best == null || e.getValue() > copy.get(best)
                || (e.getValue().equals(copy.get(best)) && e.getKey().compareTo(best) < 0)) {
            best = e.getKey();
        }
    }
    System.out.println(rank + ". " + best + " " + copy.get(best));
    copy.remove(best);
}

The third condition breaks ties alphabetically, so the output is the same on every run even though HashMap order is not stable. Two details: we compare the Integer objects with equals, not ==, because == on objects tests identity (BEG-026); and we remove from copy after the inner loop finishes, never inside it, so there is no ConcurrentModificationException (Lesson 7).