PECS Rule in Java Generics

Choosing between ? extends and ? super confuses almost everyone at first. Joshua Bloch, author of Effective Java, summed up the choice in four letters: PECS, "Producer Extends, Consumer Super". Ask one question about each parameter: does my method take values out of it (it's a producer) or put values into it (it's a consumer)? The answer picks the wildcard for you.

Producer Extends, Consumer Super

import java.util.ArrayList;
import java.util.List;
 
public class Pecs {
    static <T> void copyInto(List<? extends T> source, List<? super T> target) {
        for (T item : source) {
            target.add(item);
        }
    }
 
    public static void main(String[] args) {
        List<Integer> marks = List.of(91, 88, 95);
        List<Double> fees = List.of(1200.5, 800.0);
 
        List<Number> all = new ArrayList<>();
        copyInto(marks, all);
        copyInto(fees, all);
        System.out.println(all);
 
        List<Object> anything = new ArrayList<>(List.of("Srihitha"));
        copyInto(marks, anything);
        System.out.println(anything);
    }
}

[91, 88, 95, 1200.5, 800.0]
[Srihitha, 91, 88, 95]

How it works

1. source is a producer: the method only reads from it. So it's List<? extends T>, which accepts a list of T or of any subtype.
2. target is a consumer: the method only adds to it. So it's List<? super T>, which accepts a list of T or of any supertype.
3. With T = Number, integers and doubles both copy into a List<Number>. With T = Integer, marks copy into a List<Object>.
4. With plain List<T> for both, none of these calls would compile, because each list type would have to match exactly.

The Decision Table

PECS in the JDK

The JDK applies the rule everywhere, which is why its methods accept so many argument types:

The last row surprises people: a Comparator<Object> can sort a List<String>, because a comparator that can compare any objects can certainly compare strings. The comparator consumes elements, so it's ? super E.

Common Mistakes

Using ? extends for a list you add to. The compiler rejects every add.

Using ? super for a list you read typed values from. You only get Object back.

Using wildcards on a parameter you both read and write. Use a plain type parameter T.

Interview Corner

Practice

1. Easy: For each parameter, choose ? extends, ? super or plain T: a list you sum; a list you fill with defaults; a list you sort in place.
2. Harder: Write static <T> void moveAll(List<? extends T> from, List<? super T> to, Predicate<? super T> keep) that copies only the items the predicate accepts.