What is wildcard capture?

• List – unbounded wildcard meaning "list of some unknown type"; elements come out as Object; only null can be added
• Write restriction – the compiler blocks list.add(x) because if ? is Integer, adding a String would corrupt the list; the compiler cannot verify safety
• Capture helper – a private method with that receives List instead of List; the compiler captures the wildcard as T at the call site
• Inside the helper – T is a concrete type, so both list.get() (returns T) and list.set(i, value) (accepts T) are type-safe
• JDK usage – Collections.swap, Collections.fill, and other utility methods use this pattern internally

What is wildcard capture?

When a method accepts List, it can read elements as Object but cannot add elements (except null). This is because the compiler does not know what ? represents. The wildcard capture pattern solves this by delegating to a private generic method where the compiler captures ? as a named type parameter T.

Why can you not write to List?

The compiler blocks writes to List because it cannot guarantee type safety. The list might be a List, a List, or a List. Adding any specific type could corrupt the list.

package com.bank.demo;

import java.util.List;
import java.util.ArrayList;

public class WildcardWriteRestrictionDemo {
    static void process(List<?> list) {
        // READ: OK, elements come out as Object
        Object first = list.get(0);
        System.out.println("Read: " + first);

        // WRITE: blocked by compiler
        // list.add("test");    // COMPILE ERROR
        // list.add(42);        // COMPILE ERROR
        list.add(null);          // OK: null is always safe

        // Size, isEmpty, contains: all OK
        System.out.println("Size: " + list.size());
    }

    public static void main(String[] args) {
        List<String> accounts = new ArrayList<>(List.of("SAV2001", "CUR3001"));
        process(accounts);

        List<Integer> amounts = new ArrayList<>(List.of(10000, 25000));
        process(amounts);
    }
}

Read: SAV2001
Size: 2
Read: 10000
Size: 2

How does the capture helper pattern work?

The pattern involves two methods. The public method accepts List and delegates to a private generic helper that accepts List. At the call site, the compiler infers T from the actual argument type, capturing the wildcard.

package com.bank.demo;

import java.util.ArrayList;
import java.util.List;

public class CaptureHelperDemo {

    // Public method with wildcard: cannot do set() directly
    public static void swap(List<?> list, int i, int j) {
        // list.set(i, list.get(j)); // COMPILE ERROR: capture#1 of ?
        swapHelper(list, i, j);      // delegate to capture helper
    }

    // Private capture helper: compiler captures ? as T
    private static <T> void swapHelper(List<T> list, int i, int j) {
        T temp = list.get(i);    // read as T: OK
        list.set(i, list.get(j)); // write T: OK
        list.set(j, temp);        // write T: OK
    }

    public static void main(String[] args) {
        List<String> accounts = new ArrayList<>(List.of("SAV2001", "CUR3001", "FD4001"));
        System.out.println("Before swap: " + accounts);

        swap(accounts, 0, 2);
        System.out.println("After swap: " + accounts);
    }
}

Before swap: [SAV2001, CUR3001, FD4001]
After swap: [FD4001, CUR3001, SAV2001]

How does the JDK use wildcard capture?

The JDK uses this pattern in several utility methods. Here is a practical example similar to Collections.reverse.

package com.bank.demo;

import java.util.ArrayList;
import java.util.List;

public class ReverseDemoWithCapture {

    public static void reverse(List<?> list) {
        reverseHelper(list);
    }

    private static <T> void reverseHelper(List<T> list) {
        int size = list.size();
        for (int i = 0; i < size / 2; i++) {
            T temp = list.get(i);
            list.set(i, list.get(size - 1 - i));
            list.set(size - 1 - i, temp);
        }
    }

    public static void main(String[] args) {
        List<String> accounts = new ArrayList<>(List.of("SAV2001", "CUR3001", "FD4001"));
        reverse(accounts);
        System.out.println("Reversed: " + accounts);
    }
}

Reversed: [FD4001, CUR3001, SAV2001]

What is the difference between List and List