Advanced HashMap, TreeMap & LinkedHashMap

Go beyond put and get : count and group in one line with merge / computeIfAbsent , navigate sorted keys with TreeMap , build an LRU cache from LinkedHashMap , and update safely across threads with ConcurrentHashMap .

Learn Advanced HashMap, TreeMap & LinkedHashMap in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise…

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Before You Start

You should already be comfortable with the Collections internals and the hashCode() / equals() contract. This lesson assumes you can create a basic HashMap<K, V> and iterate it — here you'll learn the methods that make Maps genuinely powerful.

What You'll Learn

🗄️ A Real-World Analogy

Think of the three core Map types as three ways of organising a filing cabinet:

• HashMap is a cabinet where folders are thrown into whichever drawer is free. Finding any one folder is instant, but the order is chaos.
• LinkedHashMap threads a string through every folder in the order you filed them — fast lookup and a predictable walk from first to last (or, with access order, "most recently touched" last — exactly what an LRU cache needs).
• TreeMap is an alphabetised cabinet. Filing takes a moment longer, but you can ask "the folder just before M" or "everything from D to H" — the navigation methods you'll use below.

The modern methods — merge , computeIfAbsent , getOrDefault — are like a clerk who handles "add to the folder, or start a new one if it doesn't exist" in a single instruction, instead of you checking the drawer first every time.

1️⃣ The Methods That Replace "check, then put"

The old way to count things was a three-line dance: get the value, test for null , then put back the incremented number. Java 8 collapsed all of that into a handful of methods. Learn these five and most of your Map code becomes one line.

• getOrDefault(key, fallback) — read a key, but return fallback instead of null when it's missing.
• putIfAbsent(key, value) — insert only when the key isn't already there; returns the value that ended up staying.
• merge(key, value, fn) — if absent, store value ; if present, store fn(oldValue, value) . The counting workhorse.
• computeIfAbsent(key, fn) — if the key is missing, run fn(key) , store the result, and return it. Perfect for "get-or-create a List".
• computeIfPresent(key, fn) — only transform a value that already exists; does nothing for missing keys.

🎯 Your Turn #1 — Word Frequency

Fill in the blanks so merge counts each word and getOrDefault reads a count safely. The expected output is in the comments — match it exactly.

2️⃣ Ordering: LinkedHashMap, TreeMap & EnumMap

A plain HashMap gives you no order at all — iteration can appear in any sequence and may change between runs. When order matters, pick a different implementation:

Iterates in insertion order by default. Pass accessOrder=true to instead order by "most recently used" — the basis of an LRU cache.

Keeps keys sorted (natural order or a Comparator ) and adds navigation: floorKey , ceilingKey , subMap , firstKey , lastKey .

A tiny, very fast map whose keys are an enum . Backed by an array, it iterates in the enum's declaration order. Use it whenever your keys are an enum.

TreeMap navigation, in plain English: floorKey(x) = the largest key ≤ x ; ceilingKey(x) = the smallest key ≥ x ; subMap(from, to) = a live view of keys in the range [from, to) (from inclusive, to exclusive). These turn "find the price tier for a spend" into a single call.

🎯 Your Turn #2 — Price Tiers

Use TreeMap navigation to find which discount tier a spend qualifies for, then show every tier from 100 upward. Decide carefully between floorKey and ceilingKey .

3️⃣ Caches & Concurrency: LinkedHashMap LRU + ConcurrentHashMap

Two production patterns pull all of this together.

LRU cache. A cache with a size limit must drop something when it fills up; "least recently used" is the classic policy. Construct a LinkedHashMap with access order on, then override removeEldestEntry to return true once the size passes your capacity. Because access order moves every touched entry to the end, the eldest entry is always the least-recently-used one — eviction is automatic.

Thread safety. A normal HashMap is corrupted by concurrent writes. ConcurrentHashMap lets many threads read and write at once, and its merge , compute , and computeIfAbsent methods run atomically — so incrementing a counter from many threads is correct without you writing any locks.

🧩 Mini-Challenge — Group People by City

Support is faded now: only an outline is given. Build a TreeMap<String, List<String>> grouping each person under their city using computeIfAbsent , then print it. The expected output is in the comments.

Common Errors & Fixes

Pro Tips

💡 One-line counter: map.merge(key, 1, Integer::sum) is the idiomatic way to count occurrences.

💡 get-or-create: map.computeIfAbsent(key, k -> new ArrayList<>()).add(item) builds a multi-map without any null checks.

💡 Prefer EnumMap for enum keys: it's faster and uses less memory than a HashMap, and iterates in enum order for free.

💡 Need both order kinds? Sorted snapshot of a HashMap: wrap it once — new TreeMap <> (hashMap) — to print or scan in sorted order without changing the original.

📋 Quick Reference

Method / Type

Purpose

Example

getOrDefault(k, d)

Read with a fallback

map.getOrDefault("x", 0)

putIfAbsent(k, v)

Insert only if missing

map.putIfAbsent("x", 1)

merge(k, v, fn)

Accumulate (count/sum)

map.merge("x", 1, Integer::sum)

computeIfAbsent(k, fn)

Get-or-create a value

m.computeIfAbsent(k, x -> new ArrayList<>())

computeIfPresent(k, fn)

Transform if present

m.computeIfPresent(k, (key, v) -> v - 1)

floorKey / ceilingKey

Largest ≤ / smallest ≥

tree.floorKey(65)

subMap(from, to)

Range view [from, to)

tree.subMap(60, 80)

LinkedHashMap(…, true)

Access order (LRU)

new LinkedHashMap(16, .75f, true)

ConcurrentHashMap

Thread-safe, atomic ops

chm.merge(k, 1, Integer::sum)

❓ Frequently Asked Questions

🎉 Lesson Complete!

You can now count and group in one line with merge and computeIfAbsent , pick the right Map for the ordering you need, navigate sorted keys with TreeMap , build an LRU cache from LinkedHashMap , and update maps safely across threads with ConcurrentHashMap .

Next: Multithreading — create and manage threads, and use thread pools with ExecutorService .

Practice quiz

Continue this course

• Previous: Previous Lesson
• Next: Next Lesson