Краткий ответ

Захват wildcard превращает неизвестный параметр типа в отдельный временный параметр, например CAP. Метод не узнаёт его конкретное имя или класс, но гарантированно работает с одним и тем же типом внутри всей операции. Поэтому элементы можно безопасно прочитать и записать обратно в ту же коллекцию, не добавляя в неё произвольные значения.

Исторический контекст

Generics появились в Java 5, чтобы обеспечить проверку типов во время компиляции и уменьшить необходимость в явных приведениях типов. Wildcards дополнительно позволили описывать API, работающие с коллекциями неизвестного или ограниченного параметризованного типа.

При этом wildcard намеренно скрывает имя параметра типа. Для операций, где важно сохранить связь между несколькими обращениями к одному неизвестному типу, Java использует механизм capture conversion — захват wildcard.

Постановка проблемы

Пусть метод принимает коллекцию List<?>. Такой параметр означает: коллекция параметризована некоторым конкретным типом, но вызывающий код не сообщает, каким именно. Метод не может считать, что это Object, потому что фактическим типом может быть, например, String или Integer.

Неверное решение — добавить в коллекцию значение типа Object: это нарушило бы типобезопасность. Но операции, сохраняющие связь между уже прочитанными элементами и той же коллекцией, безопасны: значение, извлечённое из этой коллекции, имеет именно её неизвестный тип.

Подробное решение

При передаче List<?> компилятор концептуально захватывает wildcard и рассматривает параметр как List<CAP>, где CAP — неизвестный, но фиксированный тип. Этот тип не становится известен программисту, однако компилятор отслеживает его согласованно.

Например, перестановка двух элементов безопасна: оба значения имеют тип CAP, временная переменная также имеет тип CAP, а метод set принимает значение CAP.

import java.util.List;

class Lists {
    static void swapFirstTwo(List<?> list) {
        swap(list, 0, 1);
    }

    private static <T> void swap(List<T> list, int first, int second) {
        T value = list.get(first);
        list.set(first, list.get(second));
        list.set(second, value);
    }
}

При вызове swap(list, 0, 1) компилятор выводит T как захваченный тип CAP. Конкретное имя типа не требуется: важно лишь, что все операции внутри swap используют один и тот же T.

Захват не означает, что List<?> становится List<Object>. Произвольный объект по-прежнему нельзя добавить, поскольку он может не соответствовать фактическому типу элементов. Допустимы null и значения, полученные из этой же коллекции, если операция сохраняет их типовую совместимость.

Ситуация из практики

В библиотеке есть утилита, которая переставляет элементы в списке независимо от их типа: строк, дат или пользовательских объектов. Публичный метод должен принимать List<?>, поскольку вызывающему коду не нужно раскрывать параметр типа.

Рассматривались три варианта:

Raw-тип List упрощает запись, но отключает часть проверок типов и создаёт риск скрытых ошибок.
List<Object> не подходит: список строк или дат не является списком объектов из-за инвариантности generics.
List<?> с приватным обобщённым помощником сохраняет гибкий API и позволяет компилятору захватить один конкретный неизвестный тип.

Выбран третий вариант. Публичный контракт скрывает ненужную информацию, а вспомогательный метод получает типовой параметр, связанный со всей конкретной коллекцией. В результате перестановка выполняется без приведений типов, предупреждений и риска записать несовместимый объект.

Что кандидаты часто упускают

Зачем нужен отдельный обобщённый метод, если уже есть List<?>?

List<?> описывает неизвестный тип без доступного программисту имени. В отдельном методе этот неизвестный тип захватывается и получает имя параметра, например T. Благодаря этому компилятор может проверить, что значение, извлечённое из списка, передаётся обратно в список с тем же самым типом.
Можно ли после захвата добавить в коллекцию любой объект, приведённый к Object?

Нет. Захват делает тип более определённым для компилятора, но не раскрывает его как Object и не разрешает произвольную запись. Если фактический список имеет тип List<String>, добавление Integer должно быть запрещено, даже если ссылка на список имеет форму List<?>.
Чем захваченный тип отличается от фактического класса элементов во время выполнения?

Захваченный тип существует на уровне проверки исходного кода компилятором. Из-за стирания типов JVM обычно не хранит конкретный параметр T для таких операций: во время выполнения элементы обрабатываются через их стираемый тип, часто Object. Захват не добавляет runtime-проверку параметра; он предотвращает несовместимые операции ещё до запуска программы.