Code10x
Genericshard3-5 years

A service does `List<User> users = mapper.readValue(json, List.class);`. It compiles with an unchecked warning nobody reads, passes every test that checks `users.size()`, and then three files away, `users.get(0).getName()` throws `ClassCastException: LinkedHashMap cannot be cast to User`. Explain exactly what happened, and why the exception fires three files from the actual mistake.

At compile time, List<User> is checked as a distinct type from plain List<Object>-shaped things, but at run time none of that survives — the JVM only ever sees one class, List, with its type parameter erased to Object. That's why mapper.readValue(json, List.class) — asking Jackson for a List with no element type at all — is the only thing Jackson can build for an unknown element type: an ArrayList of raw LinkedHashMaps, one per JSON object, because there's no User anywhere in that call for it to construct instead. Assigning that result to List<User> users compiles with only a warning, not an error, precisely because erasure means List and List<User> are the same class at run time — there's nothing to actually check at the point of assignment, so no cast is inserted there. The real cast is inserted later, at the first place the compiler has to trust that the list really holds Users: users.get(0).getName() compiles to a checkcast User instruction right after the get() call, and that's where the mismatch between what's actually in the list (a LinkedHashMap) and what the code has been treating it as (a User) finally gets caught — three files and possibly several method calls away from the line that actually put the wrong thing in, because that's simply where the first read that needed the real type happened to be.

The lesson behind it →
PreviousA loop that removes expired sessions from a `List<Session>` inside a `for-each` sometimes throws `ConcurrentModificationException` and sometimes silently leaves one expired session behind, with no exception, on the same codebase. There's only one thread. Explain both outcomes from the same mechanism.Next A reporting job builds `Set<Customer> sorted = new TreeSet<>(Comparator.comparing(Customer::signedUp)); sorted.addAll(customers);` to sort and deduplicate customers by id in one step. The export has 6,000 rows where the source had 10,000. Nothing threw. What went wrong, and what's the actual rule being violated?
More on Generics
A generic `copyAll(Collection<T> from, Collection<T> to)` method fails to compile when called with a `List<Integer>` source and a `List<Number>` destination, even though copying integers into a list of numbers is obviously safe. Fix the signature, and explain exactly why each wildcard you add is necessary — not just "PECS," the actual reasoning.`List<?> xs` cannot have any non-null element added to it, even `xs.set(0, xs.get(0))` — putting back exactly what was just read out fails to compile. But a private helper method with a type parameter can swap two elements of the same `List<?>` just fine. Explain the compiler mechanism that makes the second case work, precisely — not just "it captures the type."