What is the purpose of the Collections utility class's synchronization wrappers (Collections.synchronizedList(), etc.), and how do they differ from genuinely concurrent collections like ConcurrentHashMap?

Collections.synchronizedList()/synchronizedMap()/etc. wrap a regular collection so every individual method call is synchronized on a common lock, providing basic thread safety for individual operations -- but critically, compound operations (like check-then-act patterns, or iteration) still require the caller to manually synchronize on the wrapper externally to be safe, since iteration isn't itself atomic even though each individual method call is; ConcurrentHashMap and similar java.util.concurrent collections instead provide much finer-grained, lock-striped or lock-free internal synchronization designed specifically for safe concurrent access without requiring external synchronization even for iteration, and are generally strongly preferred over the legacy synchronized wrappers for genuinely concurrent workloads.

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// Individual calls are safe:
syncList.add("item");

// But iteration STILL requires external synchronization, or ConcurrentModificationException risk remains:
synchronized (syncList) {
    for (String s : syncList) { System.out.println(s); }
}

// ConcurrentHashMap needs no such external synchronization for safe iteration
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();