Code10x
Genericshard5-8 years

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.

The original signature requires from and to to have the exact same type argument T, because generic types are invariant — List<Integer> is not a List<Number>, even though Integer is a Number, precisely so that writing a Double into what the compiler thinks is a List<Integer> through a wider reference can never happen. But copyAll doesn't actually need from and to to share one type; it needs from's elements to be assignable to whatever to accepts. The fix is Collection<? extends T> from, Collection<? super T> to: from only ever gets read from, so it can be any collection of T or a subtype (? extends T, a "producer"), and to only ever gets written to, so it can be any collection of T or a supertype (? super T, a "consumer"). That's PECS — producer extends, consumer super — and it's not an arbitrary mnemonic, it's a direct consequence of what each wildcard permits: you can read a guaranteed-safe upper bound out of an extends wildcard, and you can write a guaranteed-safe value into a super wildcard, and neither wildcard lets you do the opposite.

The lesson behind it →
PreviousA 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?Next A log pipeline needs the 10 slowest requests out of 100 million latency samples streaming past, without holding all 100 million in memory. Someone suggests a max-heap so the largest values are easy to find. What's actually the right structure, and why is a max-heap the wrong intuition here?
More on Generics
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.`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."