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

В сервисе Java ключ объекта, уже добавленного в HashMap, изменили по полю, участвующему в equals() и hashCode(). Что произойдет при последующем поиске этого ключа?

Практическая ситуация: какой метод будет вызван в Java и почему?

class Printer {
    void print(Object value) { System.out.println("Object"); }
    void print(String value) { System.out.println("String"); }

    public static void main(String[] args) {
        Object value = "текст";
        new Printer().print(value);
    }
}

Какое значение вернёт этот метод?

static int getValue() {
    try {
        return 1;
    } finally {
        return 2;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

Представьте, что после длительного прогрева первый вызов с новым типом 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()));
    }
}

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

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

import java.util.List;

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

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

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