Программирование Java

При параллельном сборе один и тот же Collector получает несколько частичных контейнеров: чем определяется их корректное объединение?

В практической ситуации параллельный стрим добавляет элементы во внешний ArrayList через forEach. Какой механизм делает результат ненадёжным?

Сравните параметр типа с верхней границей и wildcard с верхней границей: какой вариант сохраняет в результате метода конкретный тип аргумента?

В API метода нужно только читать значения типа T из коллекции и принимать коллекции T и его подтипов. Какую параметризацию параметра выбрать?

При разборе класса нужно определить результат компиляции и причину.

import java.util.List;

class Converter {
    static void convert(List<String> values) {}
    static void convert(List<Integer> values) {}
}

Скомпилируется ли этот класс?

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

Представьте, что после длительного прогрева первый вызов с новым типом Op внезапно выполняется медленнее. Объясните механизм JVM, который может вызвать такой всплеск задержки.

interface Op {
    int apply(int x);
}

final class Add implements Op {
    public int apply(int x) { return x + 1; }
}

final class Mul implements Op {
    public int apply(int x) { return x * 2; }
}

public class Main {
    static long run(Op op) {
        long sum = 0;
        for (int i = 0; i < 10_000_000; i++) sum += op.apply(i);
        return sum;
    }

    public static void main(String[] args) {
        Op add = new Add();
        for (int i = 0; i < 20; i++) run(add);
        System.out.println(run(new Mul()));
    }
}

При многократной перезагрузке Java-плагина классы остаются в Metaspace после сборки мусора. Какое условие нужно проверить первым, чтобы объяснить это поведение?

Что гарантирует Java Memory Model потоку, который успешно дождался завершения другого потока через Thread.join()?

Возможно ли потерять обновления, если общий счётчик объявлен volatile, но несколько потоков увеличивают его?

Разберите ситуацию: один поток изменяет обычное поле, затем освобождает конкретный lock, а другой после захвата того же lock читает это поле. Какие гарантии даёт Java Memory Model?

Что определяет уникальность элементов в TreeSet, если компаратор возвращает 0 для двух объектов, не равных по equals?

Какой механизм объясняет выброс ConcurrentModificationException итератором ArrayList после структурного изменения коллекции?

В практической ситуации ключ с изменяемым полем уже помещён в HashMap, после изменения этого поля get по тому же объекту возвращает null. Какой механизм контракта объясняет это поведение?

Вызов перегруженного метода через ссылку базового типа: какой тип ссылки определяет доступный набор перегрузок?

Как Java разрешает конфликт одинаковых default-методов, унаследованных классом от двух интерфейсов?

При вызове переопределённого экземплярного метода через ссылку базового класса что определяет выбираемую реализацию?

Как Java определяет порядок инициализации экземпляра при создании объекта?

В какой момент Java выбирает перегруженный метод: при компиляции или во время выполнения?

Что фактически передаётся в метод Java при передаче переменной ссылочного типа?