Frequency Counting Patterns with Hash Maps

Pattern 1 — count occurrences

Map<String, Integer> counts = new HashMap<>();
for (String word : words) {
    counts.merge(word, 1, Integer::sum);
}

String mostCommon = counts.entrySet().stream()
        .max(Map.Entry.comparingByValue())
        .map(Map.Entry::getKey)
        .orElse(null);

Pattern 2 — have I seen this before?

A set answers membership in O(1), which converts "for each element, scan the rest" from O(n²) into one pass. The classic example is two sum on an unsorted array — where two pointers is unavailable because sorting would destroy the original indices.

int[] twoSum(int[] a, int target) {
    Map<Integer, Integer> seen = new HashMap<>();   // value -> index
    for (int i = 0; i < a.length; i++) {
        Integer j = seen.get(target - a[i]);
        if (j != null) return new int[]{j, i};
        seen.put(a[i], i);
    }
    return new int[]{-1, -1};
}

O(n) time, O(n) space. The trade is explicit and worth saying out loud: you spend memory to buy a linear scan.

Pattern 3 — group by a computed key

When items belong together under some derived property, compute that property and use it as the map key. "Group anagrams" is the standard example: two words are anagrams exactly when their sorted characters match, so the sorted string is the key.

List<List<String>> groupAnagrams(String[] words) {
    Map<String, List<String>> groups = new HashMap<>();
    for (String word : words) {
        char[] chars = word.toCharArray();
        Arrays.sort(chars);
        String key = new String(chars);          // the canonical form
        groups.computeIfAbsent(key, k -> new ArrayList<>()).add(word);
    }
    return new ArrayList<>(groups.values());
}

O(n x k log k) for n words of length k, dominated by sorting each word. Using a 26-character count signature as the key instead removes the sort and brings it to O(n x k) — a good optimisation to offer once the first version works.

Choosing the right structure