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

Неограниченный wildcard обозначает неизвестный, но конкретный тип элемента. Компилятор выполняет capture conversion: временно рассматривает wildcard как отдельный захваченный тип, который неизвестен вызывающему коду. Поэтому элемент безопасно читается как Object, но добавлять можно только null или значения, уже доказанно имеющие этот захваченный тип.

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

Generics появились в Java 5, чтобы проверять совместимость типов во время компиляции и уменьшить необходимость в приведениях типов. При этом Java сохранила совместимость со старым кодом и реализовала generics через стирание типов.

Wildcards понадобились для описания API, которому не важно, какой именно параметр типа использует коллекция. Например, метод может принять коллекцию любого типа и безопасно читать из неё значения, не объявляя конкретный тип элемента.

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

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

Например, коллекция строк может быть передана как коллекция с неизвестным типом. Добавление числа через такую ссылку сделало бы возможным появление числа внутри коллекции строк и привело бы к ошибке при последующем чтении.

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

Компилятор воспринимает неизвестный тип как некоторый уникальный тип CAP, о котором известно только то, что он является допустимым типом элементов конкретной коллекции. Для чтения значение типа CAP можно безопасно представить как Object, поскольку любой ссылочный тип является подтипом Object.

Обратное направление небезопасно: значение типа Object не обязано быть CAP. Поэтому добавление произвольного объекта запрещено. Исключение составляет null, поскольку он совместим с любым ссылочным типом.

import java.util.List;

class CollectionsUtil {
    static void swapFirstTwo(List<?> values) {
        swapCaptured(values);
    }

    private static <T> void swapCaptured(List<T> values) {
        T first = values.get(0);
        values.set(0, values.get(1));
        values.set(1, first);
    }
}

Метод swapCaptured получает конкретный захваченный тип T. Он не знает его название, но может безопасно перемещать значения этого типа внутри той же коллекции. Это не позволяет добавить произвольный объект, зато позволяет выполнять операции, сохраняющие тип элементов.

List<?> отличается от List<Object>. Первый вариант означает «список некоторого неизвестного типа», а второй — «список именно объектов Object». Из-за инвариантности generics список строк не является списком объектов, поэтому List<String> нельзя передать туда, где требуется List<Object>.

Ограничение действует на этапе компиляции. Во время выполнения конкретный параметр типа обычно стёрт, но это не делает небезопасную операцию допустимой: компилятор проверяет её до запуска программы.

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

Вспомогательному методу коллекций нужно переставить местами два первых элемента любой изменяемой коллекции. Входной тип заранее неизвестен: это может быть список строк, дат или DTO.

Первый вариант — принимать коллекцию с параметром Object. Он не подходит из-за инвариантности: коллекция строк не является коллекцией объектов. Использование сырого типа формально решает проблему передачи, но отключает проверки типов и может привести к ошибкам во время выполнения.

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

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

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

Почему чтение из коллекции с неизвестным типом имеет тип Object?

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

Это не означает, что исходные элементы действительно имеют тип Object. Они могут быть строками или экземплярами другого класса; Object — лишь наиболее безопасный тип, доступный вызывающему коду без дополнительной информации.
Почему захваченный тип позволяет переставлять элементы, но не позволяет добавить заранее созданный объект?

После capture conversion все операции внутри generic-метода используют один и тот же неизвестный тип T. Значение, полученное из этой коллекции, уже имеет тип T, поэтому его можно записать обратно в ту же коллекцию.

Произвольный объект имеет тип Object, и компилятор не может доказать, что он является T. Захват типа сохраняет неизвестность параметра, но не превращает её в Object и не даёт права подменять значения.
Можно ли определить фактический тип элементов такой коллекции во время выполнения?

Надёжно определить параметр типа через сам wildcard нельзя. Из-за стирания типов информация о параметре generics обычно отсутствует у объекта коллекции во время выполнения.

Реальные элементы можно проверять через instanceof, но это проверка объектов, а не восстановление параметра типа коллекции. Такой подход может быть оправдан на границе с внешними данными, однако он переносит часть гарантий с компилятора на код выполнения и требует явно обрабатывать возможные несовпадения типов.