Let’s Understand What is Hashing

Hashing is simple. Suppose you have some data—a character, a number, a word—and you convert it into a special code called a hash. Every time you hash the same thing, you get the same code.

Why does this matter? Because it helps us find things quickly in programming, especially when we are solving problems where we need to count, check, or map things.

---

Why Hashing is Useful

Hashing is very handy in many problems. For example:

• Character Frequency: Count how many times 'a' comes in "banana".
• Anagram Check: Is "nasa" an anagram of "sana"?
• Duplicate Elements: Check if the same number comes more than once in an array.
• Unique Elements: Find the numbers that appear only once.
• Majority Element: Find the number that occurs the most.
• Two-Sum Problem: Find two numbers whose sum is equal to a target.

Basically, if you want to count, check existence, or quickly find things, hashing is your friend.

---

When Should You Use a HashMap?

Think of HashMap as a quick way to store and look up things. Use it when you want to:

• Count frequencies
• Check duplicates
• Check if something exists
• Map things together
• Store already calculated results (caching/memoization)

And the best part? All these operations happen very fast, almost constant time on average.

So next time you see a problem like “count this” or “check that,” your brain should immediately think: “Its Time For Hashmap!”

---

Patterns You Should Know

HashMaps are very useful in certain patterns:

• Frequency Map Pattern: Count how many times each element comes.
• Two-Sum Pattern: Find pairs that add up to a target.
• Prefix/Suffix Sum Patterns: Useful in subarray problems.
• Existence Check: Quickly check if something is already there.
• Caching / Memoization: Store results and reuse.
• Grouping: Group elements based on some property.
• Frequency Distribution: Who appears how many times.

Master these, and most HashMap problems will become easy.

---

Basic Operations

map.put("key", value);                  // Add or update
Integer value = map.get("key");         // Get value
Integer removed = map.remove("key");    // Remove key
map.putIfAbsent("key", value);          // Add if not already there
map.replace("key", value);              // Replace value
boolean updated = map.replace("key", oldValue, newValue); // Replace only if value matches

Checking Methods

boolean exists = map.containsKey("key"); // Is key present?
boolean isEmpty = map.isEmpty();         // Is map empty?
int size = map.size();                   // How many entries?```

#### Iteration :

```java
Set<String> keys = map.keySet();                        // All keys
Set<Map.Entry<String, Integer>> entries = map.entrySet(); // Key-value pairs

Functional Updates :

map.compute("key", (k, v) -> v == null ? 1 : v + 1);   // Compute and update
map.computeIfAbsent("key", k -> 10);                   // Insert if absent
map.computeIfPresent("key", (k, v) -> v + 1);         // Update if present

Advanced Utilities

Integer value = map.getOrDefault("key", 0); // Get value or default
map.clear();                                // Remove all entries

Wrapping Up Hashing and HashMaps are super useful tools. Once you understand them and practice common patterns, problems that looked tough will start feeling easy.