What is the difference between 'E', 'T', and '?' for Java generics?

Understanding Java Generics: E, T, and ?

Explore the fundamental differences between 'E', 'T', and '?' in Java generics, and learn how to effectively use them for type safety and flexibility in your code.

Java generics are a powerful feature introduced in Java 5 that allow you to write code that works with different types while maintaining type safety. They enable you to define classes, interfaces, and methods with type parameters, making your code more reusable and less prone to runtime errors. However, the various symbols used in generics, particularly E, T, and ?, can often be a source of confusion for developers. This article will demystify these symbols, explaining their specific roles and when to use each one.

Type Parameters: E and T

The letters E and T are commonly used as type parameters in Java generics. While there's no strict rule enforcing their use, they are conventions that help improve code readability. Both E and T represent a type variable that will be replaced by a concrete type at compile time. The choice between E and T is largely semantic, often indicating the role of the type parameter within the context of the class or method.

'E' for Element

E is typically used when the type parameter represents an element in a collection. For instance, in the java.util.Collection interface, E denotes the type of elements that the collection will hold. This convention makes it immediately clear that the generic type is related to the items stored within the data structure.

public interface Collection<E> {
    boolean add(E e);
    Iterator<E> iterator();
    // ... other methods
}

Example of 'E' in the Collection interface

'T' for Type

T is a more general-purpose type parameter, often used when the type can be anything and doesn't specifically represent an 'element' of a collection. It's frequently seen in generic classes or methods where the type parameter is a placeholder for a general type. For example, in a generic utility method that operates on a single type, T is a common choice.

public class Box<T> {
    private T content;

    public Box(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }
}

// Usage:
Box<String> stringBox = new Box<>("Hello");
String value = stringBox.getContent();

Example of 'T' in a generic Box class

Wildcard: '?'

The question mark ? in Java generics is known as the unbounded wildcard. Unlike E or T, which are type parameters that define a specific type for a class or method, ? is used in type arguments to represent an unknown type. It's primarily used in method signatures to increase the flexibility of generic code, allowing methods to accept a wider range of generic types.

Unbounded Wildcard <?>

When ? is used without any bounds (e.g., List<?>), it means "a list of unknown type." This is useful when you want to write a method that can operate on any generic List, regardless of its element type. However, with an unbounded wildcard, you can only read elements as Object and cannot add new elements (except null) because the compiler doesn't know what type of elements the list is supposed to hold.

public void printList(List<?> list) {
    for (Object o : list) {
        System.out.println(o);
    }
    // list.add("some string"); // Compile-time error!
    list.add(null); // This is allowed
}

List<String> strings = Arrays.asList("A", "B");
List<Integer> integers = Arrays.asList(1, 2);

printList(strings);
printList(integers);

Using the unbounded wildcard <?> to print elements from any list

Bounded Wildcards: <? extends T> and <? super T>

Wildcards become even more powerful when combined with extends or super, creating bounded wildcards. These allow you to specify an upper or lower bound for the unknown type, providing more flexibility than a fixed type parameter while maintaining type safety.

PECS Principle: Producer Extends, Consumer Super

Upper Bounded Wildcard: <? extends T>

<? extends T> means "an unknown type that is T or a subtype of T." This is used when you want to read values from a generic collection. You can safely retrieve elements from such a collection, as you know they will be at least of type T (or a subtype), so they can be assigned to a variable of type T. However, you cannot add elements to such a collection (except null), because the compiler doesn't know the exact subtype.

public void processNumbers(List<? extends Number> numbers) {
    for (Number n : numbers) {
        System.out.println(n);
    }
    // numbers.add(new Integer(10)); // Compile-time error!
    // numbers.add(new Double(10.0)); // Compile-time error!
}

List<Integer> ints = Arrays.asList(1, 2, 3);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);

processNumbers(ints);
processNumbers(doubles);

Using <? extends Number> to process lists of Number or its subtypes

Lower Bounded Wildcard: <? super T>

<? super T> means "an unknown type that is T or a supertype of T." This is used when you want to add values to a generic collection. You can safely add instances of T (or any subtype of T) to such a collection, as you know the collection can hold at least Ts. However, when reading from such a collection, you can only retrieve elements as Object because the exact supertype is unknown.

public void addNumbers(List<? super Integer> list) {
    list.add(10);
    list.add(20);
    // Integer i = list.get(0); // Compile-time error! Must cast to Object first.
    Object o = list.get(0);
}

List<Number> numbers = new ArrayList<>();
List<Object> objects = new ArrayList<>();

addNumbers(numbers);
addNumbers(objects);

Using <? super Integer> to add Integer values to lists of Integer or its supertypes

Summary and Best Practices

Understanding E, T, and ? is crucial for writing robust and flexible Java generic code. Here's a quick recap and some best practices:

Comparison of E, T, and ?

1. Use E for Collection Elements

When defining generic collections or methods that operate on elements within a collection, E is the conventional and most readable choice.

2. Use T for General Type Parameters

For generic classes or methods where the type parameter is a placeholder for a general type, T is appropriate. This is common in utility classes or methods that work with a single type.

3. Use ? for Flexibility in Method Signatures

The wildcard ? is used in method parameters to accept a range of generic types. It's not for defining new generic types but for making existing generic types more flexible.

4. Apply PECS (Producer Extends, Consumer Super)

This mnemonic helps remember when to use bounded wildcards: If your generic type is a 'producer' (you only read from it), use <? extends T>. If it's a 'consumer' (you only write to it), use <? super T>. If you both read and write, use a specific type parameter like T.