Deep Dive into Java Generic Wildcards: <? super T> vs <? extends T>

Fundamental Concepts of Generic Wildcards

Java's generic system provides flexible type parameterization through wildcards, with <? super T> and <? extends T> being the most commonly used forms. They represent lower and upper bounds for type parameters respectively, directly affecting collection read and write capabilities.

Analysis of <? extends T> Wildcard

When using <? extends T> to declare a collection, it can reference any list of T or its subtypes. For example, List<? extends Number> can point to ArrayList<Number>, ArrayList<Integer>, or ArrayList<Double>.

Read Operation Characteristics

When reading elements from a <? extends T> collection, you can safely obtain instances of type T. This is because whether the actual storage is T or its subclass, it can be upcast to T. For example:

List<? extends Number> numbers = new ArrayList<Integer>();
Number num = numbers.get(0);  // Safe read

Write Operation Limitations

Adding elements to a <? extends T> collection is strictly limited. Since the compiler cannot determine the actual stored type, any addition operation could violate type safety. For example:

List<? extends Number> numbers = new ArrayList<Integer>();
// numbers.add(new Integer(1));  // Compilation error
// numbers.add(new Double(1.0)); // Compilation error

Analysis of <? super T> Wildcard

Conversely, <? super T> allows collections to reference lists of T or its supertypes. For example, List<? super Integer> can point to ArrayList<Integer>, ArrayList<Number>, or ArrayList<Object>.

Write Operation Characteristics

This declaration supports adding instances of T and its subtypes to the collection, since any subclass of T can be safely stored in a superclass collection of T:

List<? super Integer> integers = new ArrayList<Number>();
integers.add(new Integer(10));  // Safe write
integers.add(new Integer(20));  // Safe write

Read Operation Limitations

When reading from a <? super T> collection, you can only guarantee obtaining Object instances, as the actual storage could be any supertype:

List<? super Integer> integers = new ArrayList<Object>();
Object obj = integers.get(0);  // Can only read as Object

Detailed Explanation of PECS Principle

The PECS (Producer Extends, Consumer Super) principle provides clear guidance for wildcard usage:

Producer Scenario (Producer Extends)

When a collection acts as a data producer (primarily performing read operations), use <? extends T>. This ensures safe retrieval of T-type data from the collection while explicitly prohibiting write operations.

Consumer Scenario (Consumer Super)

When a collection acts as a data consumer (primarily performing write operations), use <? super T>. This allows adding T-type data to the collection, but reading only yields the most generic Object type.

Practical Application Examples

Collection Copy Operation

The Collections.copy method in Java standard library perfectly demonstrates PECS principle application:

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i));
    }
}

Here, the source list src acts as producer using <? extends T>, while the destination list dest acts as consumer using <? super T>.

Comparator Design

In TreeSet constructor, using <? super E> provides greater flexibility:

TreeSet(Comparator<? super E> comparator)

This allows using comparators that can compare E type or its supertypes, enhancing API generality.

Maximum Value Calculation

The signature of Collections.max method showcases complex wildcard usage:

public static <T extends Comparable<? super T>> T max(Collection<T> coll)

This design allows type T to be comparable with any supertype, not just itself.

Advanced Application Scenarios

Write-Only Data Structures

Consider a write-only data sink interface:

interface Sink<T> {
    void flush(T t);
}

Using lower bounded wildcards properly handles writing from different type collections:

public static <T> T writeAll(Collection<T> coll, Sink<? super T> snk) {
    T last = null;
    for (T t : coll) {
        last = t;
        snk.flush(last);
    }
    return last;
}

Wildcard Capture

In certain specific scenarios, compilers can infer unknown types through wildcard capture mechanism:

Set<?> unknownSet = new HashSet<String>();
Set<?> s = Collections.unmodifiableSet(unknownSet);

Although the type of unknownSet is unknown, since unmodifiableSet is safe for any Set type, the compiler permits this operation.

Best Practices Summary

In practical development, choose appropriate wildcards based on specific requirements:

• Use <? extends T> when frequently reading data
• Use <? super T> when frequently writing data
• Use concrete type parameters <T> when both reading and writing are needed
• Consider using wildcards in API design to enhance flexibility

By deeply understanding the semantics and behaviors of these wildcards, developers can write safer, more flexible generic code, effectively avoiding type conversion errors and runtime exceptions.