ConcurrentHashMap

// ── Thread-safe operations with no explicit locking: ─────────────────
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// Safe from multiple threads simultaneously:
map.put("Alice", 90);
map.put("Bob",   85);

// Reads are lock-free:
Integer score = map.get("Alice");   // fast, no lock

// ── Atomic compound operations: ───────────────────────────────────────

// putIfAbsent — atomic: check-and-insert without race condition:
map.putIfAbsent("Carol", 78);    // inserts only if Carol not present
map.putIfAbsent("Alice", 100);   // no-op — Alice already present

// computeIfAbsent — compute value atomically if key absent:
// SAFE in concurrent context — mapping function called at most once:
Map<String, List<String>> groups = new ConcurrentHashMap<>();
groups.computeIfAbsent("team-a", k -> new CopyOnWriteArrayList<>()).add("Alice");
groups.computeIfAbsent("team-a", k -> new CopyOnWriteArrayList<>()).add("Bob");
// "team-a" list created once, both threads add to same list

// merge — atomic increment:
ConcurrentHashMap<String, Long> wordCount = new ConcurrentHashMap<>();
String[] words = {"cat", "dog", "cat", "bird", "cat", "dog"};
for (String word : words) {
    wordCount.merge(word, 1L, Long::sum);
}
System.out.println(wordCount);  // {cat=3, dog=2, bird=1}

// compute — atomically update:
map.compute("Alice", (k, v) -> v == null ? 1 : v + 10);

// ── No null keys or values: ───────────────────────────────────────────
try { map.put(null, 1);      } catch (NullPointerException e) { }
try { map.put("key", null);  } catch (NullPointerException e) { }
// NullPointerException for both — unlike HashMap

// Distinguish absent from null-mapped:
// map.get(key) returning null means key is ABSENT (no null values allowed)
if (map.get("Dave") == null) {
    System.out.println("Dave not in map");  // safe — null means absent
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// Populate with some data:
for (int i = 0; i < 1000; i++) {
    map.put("key-" + i, i);
}

// ── forEach with parallelism: ─────────────────────────────────────────
map.forEach(100, (k, v) -> {
    if (v > 990) System.out.println(k + "=" + v);
});
// 100 = parallelismThreshold: parallel if >100 entries (this map has 1000)

// ── search — find first entry matching condition: ─────────────────────
String found = map.search(100, (k, v) -> v > 995 ? k : null);
System.out.println("Found: " + found);  // some key with value > 995

// ── reduce — compute aggregate: ──────────────────────────────────────
int total = map.reduce(100,
    (k, v) -> v,          // transformer: get the value
    Integer::sum           // reducer: sum all values
);
System.out.println("Sum: " + total);   // sum of 0..999 = 499500

// ── mappingCount() — better than size() for large maps: ───────────────
long count = map.mappingCount();   // long — handles maps > Integer.MAX_VALUE
System.out.println("Count: " + count);  // 1000

// ── Common usage pattern — concurrent frequency counter: ──────────────
public class WordFrequencyCounter {
    private final ConcurrentHashMap<String, LongAdder> counts =
        new ConcurrentHashMap<>();

    public void count(String word) {
        // computeIfAbsent is atomic — LongAdder created once per word:
        counts.computeIfAbsent(word, k -> new LongAdder()).increment();
        // LongAdder provides thread-safe increment with low contention
    }

    public long getCount(String word) {
        LongAdder adder = counts.get(word);
        return adder == null ? 0 : adder.sum();
    }

    public Map<String, Long> getTopN(int n) {
        return counts.entrySet().stream()
            .sorted(Map.Entry.<String, LongAdder>comparingByValue(
                Comparator.comparingLong(LongAdder::sum)).reversed())
            .limit(n)
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> e.getValue().sum(),
                (a, b) -> a,
                LinkedHashMap::new));
    }
}