Count occurrences of each word.

Hook: This is one of those interview questions that looks tiny, but it tests whether you can turn messy text into a clean data structure — like sorting a pile of receipts into labeled folders.

Question: How do you count occurrences of each word in a sentence or paragraph using Java?

Answer: I would scan the text word by word, normalize each word to a common form such as lowercase, and store counts in a Map. Each time I see a word, I either add it to the map with count 1 or increase its existing count. This gives fast counting and handles repeated words naturally.

Interview-Ready Answer: I’d use a Map<String, Integer> to count words. First I normalize the text, usually by converting to lowercase and extracting words cleanly so punctuation does not create fake tokens. Then I walk through each word and update its count with merge or getOrDefault. That gives me an average O(n) solution, where n is the number of words, and it scales well for large text.

What this problem is really asking

Detailed Explanation: The goal is to transform raw text into counts. In simple words, you want a frequency table: a list of words and how many times each one appears. A Map is perfect because it connects each word to one number.

1. Normalize the text. Convert to lowercase so Java and java count as the same word. This step avoids split counts caused by case differences.
2. Extract real words. Do not rely on spaces alone if punctuation matters. A regex like [\p{L}\p{Nd}']+ finds letters, digits, and apostrophes, so don't stays one word instead of becoming don and t.
3. Update counts. For each word, increase its number in the map. In Java, merge(word, 1, Integer::sum) is a neat way to say “add one, or start at one if missing.”
4. Return or print the result. The map is your final answer. If you want predictable output order, use LinkedHashMap; if you want sorted keys, use TreeMap.

Under the hood

A HashMap stores keys in buckets based on their hash code. A hash code is a number used to place items quickly, so lookups are usually fast. When you count words, each unique word becomes one key, and the map updates that key many times. That is why the average cost per update is close to constant time.

Common implementation choices

Here, k is the number of distinct words. For most interview solutions, HashMap or LinkedHashMap is the best default because counting stays simple and fast.

Performance notes interviewers like

• Time: Average O(n), where n is the number of words scanned.
• Space: O(k) for distinct words, because each unique word needs one map entry.
• Realistic scale: A paragraph may have 100 words, a log file may have millions, and the map size depends on vocabulary, not total length.
• Why regex matters: Splitting on spaces alone fails on punctuation like hello,world or end..

Important edge cases

• Empty or null input: Return an empty map instead of throwing an exception.
• Punctuation: Decide whether word and word, should count together. In interviews, say your rule clearly.
• Case sensitivity: Usually count case-insensitively unless the problem says otherwise.
• Locale: Use Locale.ROOT for stable lowercase conversion; this avoids language-specific surprises.

Memory Hook: Think of words as mail and the map as a row of labeled mailboxes: every time the same letter arrives, you drop one more copy into the same box.

Real-World Story: Imagine a chat app that scans messages to show trending words in a support channel. The service reads each message, normalizes it, and updates counts for dashboards and search suggestions. If the developer forgets to remove punctuation, the dashboard may show error, error!, and error? as three separate “top words,” which makes the trend data wrong.

In production, that bug looks harmless at first, but users notice weird analytics: support teams search for a term and miss messages because the index is fragmented. Logs often show lots of near-duplicate tokens, and the UI may display misleading top keywords. The fix is not in the database — it is in text normalization before counting.

Follow-up & Tricky Questions:

• How would you keep the words in alphabetical order? Use a TreeMap instead of a HashMap. It keeps keys sorted, but each update becomes O(log k) instead of average O(1).
• How would you preserve the order of first appearance? Use a LinkedHashMap. It stores entries in insertion order, which is useful when you want the output to match the original text flow.
• How would you count words in a very large file? Read line by line with BufferedReader instead of loading the whole file into memory. That keeps memory use lower and is the standard approach for large input.
• How would you ignore common stop words like “the” and “a”? Build a Set of stop words and skip them during counting. This is common in search and analytics systems.
• How would you make this thread-safe? If multiple threads update the same counts, use synchronization or concurrent structures like ConcurrentHashMap with atomic updates. Otherwise, counts can be lost during race conditions, which are timing bugs caused by threads interfering with each other.
• What if the input contains Unicode words? Use Unicode-aware matching, like the regex in the code, and lowercase with Locale.ROOT. That avoids splitting non-English letters incorrectly.
• Tricky: Does split(" ") handle all whitespace? No. It fails on multiple spaces and tabs unless you use a whitespace regex, and even then punctuation still needs cleanup.
• Tricky: Is hello the same as Hello? Only if you normalize case first. If you forget, you will count them as two different words.
• Tricky: Can apostrophes be part of a word? Yes, depending on your rule. If you want don't counted as one word, your tokenizer must allow apostrophes inside tokens.

Common Mistakes:

• Counting punctuation as words. Fix: strip punctuation or use a word-matching regex instead of plain split(" ").
• Forgetting case normalization. Fix: convert to lowercase with Locale.ROOT before counting.
• Using the wrong map for the goal. Fix: choose HashMap for speed, LinkedHashMap for stable order, or TreeMap for sorting.
• Not handling null or blank input. Fix: return an empty map so the method is safe and easy to reuse.

Memory Hook: “Same word, same mailbox.” Picture each word walking to its own labeled mailbox, and every repeat just drops in one more letter.

Cheat Sheet:

• Use a Map<String, Integer> for word frequencies.
• Normalize case before counting.
• Extract words carefully; spaces alone are not enough.
• HashMap is average O(1) per update.
• LinkedHashMap keeps insertion order.
• Return an empty map for null or blank input.

Practice Tasks:

• Start with a sentence and print word counts in any order.
• Modify the solution to sort the output by word alphabetically.
• Change the tokenizer so can't is counted as one word, but rock-n-roll is split into three.