JV Java · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

Лямбды и функциональные интерфейсы

Разбирает тему «Лямбды и функциональные интерфейсы» на практических сценариях: поиск дефектов, сравнение решений и оценка последствий. Вопросы перемешаны: встречаются трассировка, ошибка компиляции, выбор правки, граничный сценарий и оценка инженерного компромисса. Базовая версия — Java 25 LTS; если версия не названа отдельно, используются устойчивые правила, совместимые с Java 21.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. В каждом вопросе верен только один вариант; близкие ответы различаются стадией ошибки, порядком действий или границей контракта. После завершения вы увидите общий результат, результаты по 5 тематическим шкалам и объяснения.

Вопрос 1 из 25

Какое замечание о сопровождении или производительности темы «Предикаты» в разделе «Лямбды и функциональные интерфейсы» справедливо?

Композиция полезна для небольших чистых этапов, но не заменяет обработку ошибок и контекстные сообщения. Композиция правил уменьшает дублирование, но длинная цепочка без названий скрывает причину отказа. Композиция правил увеличивает дублирование, но длинная цепочка без названий скрывает причину отказа. Ограничение локальных переменных уменьшает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Ссылка короче, но перегруженные методы могут сделать вывод типов неоднозначным.

Вопрос 2 из 25

Как лучше исправить или прояснить поведение темы «Предикаты» в разделе «Лямбды и функциональные интерфейсы»?

// Фрагмент на ревью
java.util.function.Predicate<String> nonEmpty = s -> !s.isEmpty();
java.util.function.Predicate<String> longEnough = s -> s.length() > 3;
System.out.println(nonEmpty.and(longEnough).test(""));

Выносить повторяющиеся проверки в именованные Predicate и отдельно тестировать порядок короткого замыкания и работу с null. Выбирать compose или andThen по направлению потока данных и закреплять порядок тестом на функциях, для которых перестановка меняет результат. Использовать reduce/collect или изменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Оставлять ссылку на метод, когда получатель и аргументы очевидны; иначе явная лямбда читается лучше. Передать Clock или функцию получения времени как зависимость.

Вопрос 3 из 25

На какое правило следует опираться при разборе темы «Захват переменных» в разделе «Лямбды и функциональные интерфейсы»?

Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, andThen — позже. Функциональный код проще тестировать, если лямбды чисты, детерминированы и вынесены из инфраструктурного контекста. Ссылка на метод — сокращённая форма совместимой лямбды; вид ссылки определяет, где берётся получатель. Predicate<T> принимает T и возвращает boolean; методы and и or используют короткое замыкание. Лямбда может захватывать локальную переменную, только если она объявлена final или остаётся фактически неизменяемой.

Вопрос 4 из 25

Какое ограничение механизма «Предикаты» нельзя упускать при работе с разделом «Лямбды и функциональные интерфейсы»?

// Минимальный пример
java.util.function.Predicate<String> nonEmpty = s -> !s.isEmpty();
java.util.function.Predicate<String> longEnough = s -> s.length() > 3;
System.out.println(nonEmpty.and(longEnough).test(""));

Predicate.not удобен для отрицания, но не превращает null-небезопасную проверку в безопасную. Function.identity возвращает тот же объект, а не копию. Predicate.not вызывает исходный Predicate только для ненулевых значений. Поле объекта можно менять из лямбды, но это не делает операцию потокобезопасной. Predicate.not превращает исключение исходного Predicate в результат false.

Вопрос 5 из 25

На какое правило следует опираться при разборе темы «Функциональные преобразования» в разделе «Лямбды и функциональные интерфейсы»?

Predicate<T> принимает T и возвращает boolean; методы and и or используют короткое замыкание. map оборачивает обычный результат функции, flatMap ожидает функцию, уже возвращающую Optional. Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, andThen — позже. Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, compose — позже. Function<T,R> преобразует T в R; andThen выполняет переданную функцию раньше, andThen — позже.

Вопрос 6 из 25

Что важно учитывать при применении механизма «Функциональные преобразования» из раздела «Лямбды и функциональные интерфейсы» в рабочем проекте?

Ограничение локальных переменных уменьшает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Инъекция функции делает код гибким, но публичный API из десятков параметров-функций может стать труднее обычного объекта стратегии. Композиция правил уменьшает дублирование, но длинная цепочка без названий скрывает причину отказа. Композиция полезна для небольших чистых этапов, но не заменяет обработку ошибок и контекстные сообщения. Цепочка flatMap хорошо описывает зависимые поиски, но длинная последовательность может скрыть причину отсутствия.

Вопрос 7 из 25

Что нужно отдельно проверить на границе контракта «Функциональные преобразования» в разделе «Лямбды и функциональные интерфейсы»?

// Минимальный пример
java.util.function.Function<Integer,Integer> plusOne = x -> x + 1;
java.util.function.Function<Integer,Integer> timesTwo = x -> x * 2;
System.out.println(plusOne.andThen(timesTwo).apply(3));

obj::method захватывает конкретный объект в момент создания ссылки, а Type::instanceMethod получает объект первым аргументом. Predicate.not удобен для отрицания, но не превращает null-небезопасную проверку в безопасную. Function.identity возвращает тот же объект, а не копию. Function.identity не возвращает тот же объект, а не копию. Function.identity возвращает новый объект, а не копию.

Вопрос 8 из 25

Какая правка точнее всего устраняет причину проблемы по теме «Захват переменных» в разделе «Лямбды и функциональные интерфейсы»?

// Фрагмент на ревью
int[] sum = {0};
java.util.List.of(1,2,3).forEach(x -> sum[0] += x);
System.out.println(sum[0]);

Передать Clock или функцию получения времени как зависимость. Выбирать compose или andThen по направлению потока данных и закреплять порядок тестом на функциях, для которых перестановка меняет результат. Использовать reduce/collect или неизменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Использовать reduce/collect или изменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Использовать неизменяемую реализацию или защитную копию, если нужно запретить изменение содержимого.

Вопрос 9 из 25

Какое утверждение о механизме «Ссылки на методы» верно в контексте раздела «Лямбды и функциональные интерфейсы»?

Лямбда может захватывать локальную переменную, только если она объявлена final или остаётся фактически неизменяемой. Ссылка на метод — сокращённая форма совместимой лямбды; вид ссылки определяет, где берётся получатель. Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, andThen — позже. Функциональный код проще тестировать, если лямбды чисты, детерминированы и вынесены из инфраструктурного контекста. map оборачивает обычный результат функции, flatMap ожидает функцию, уже возвращающую Optional.

Вопрос 10 из 25

Какой диагноз для кода по теме «Функциональные преобразования» в разделе «Лямбды и функциональные интерфейсы» будет точным?

java.util.function.Function<Integer,Integer> plusOne = x -> x + 1;
java.util.function.Function<Integer,Integer> timesTwo = x -> x * 2;
System.out.println(plusOne.andThen(timesTwo).apply(3));

Для пустой строки второй предикат не вызывается, потому что первый уже вернул false. plusOne.andThen(timesTwo) для 2 даёт 8, а compose дал бы 7. plusOne.andThen(timesTwo) для 4 даёт 8, а compose дал бы 7. Код не компилируется: после изменения sum переменная перестаёт быть фактически неизменяемой и не может захватываться лямбдой. plusOne.andThen(timesTwo) для 3 даёт 8, а compose дал бы 7.

Вопрос 11 из 25

Что следует изменить в разделе «Лямбды и функциональные интерфейсы», чтобы сохранить замысел и соблюсти контракт «Тестирование и диагностика»?

// Фрагмент на ревью
java.util.function.Supplier<String> token = () ->
    java.time.LocalDateTime.now().toString();
System.out.println(token.get());

Оставить LocalDateTime.now(), но округлять строку до минут, чтобы результат менялся реже. Оставлять ссылку на метод, когда получатель и аргументы очевидны; иначе явная лямбда читается лучше. Использовать reduce/collect или изменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Выносить повторяющиеся проверки в именованные Predicate и отдельно тестировать порядок короткого замыкания и работу с null. Передать Clock или функцию получения времени как зависимость.

Вопрос 12 из 25

Какой граничный случай особенно важен для темы «Тестирование и диагностика» в разделе «Лямбды и функциональные интерфейсы»?

// Минимальный пример
java.util.function.Supplier<String> token = () ->
    java.time.LocalDateTime.now().toString();
System.out.println(token.get());

Поле объекта можно менять из лямбды, но это не делает операцию потокобезопасной. Function.identity возвращает тот же объект, а не копию. Стек вызовов лямбд может содержать синтетические имена, поэтому полезны короткие именованные методы для важных этапов. sorted и distinct могут требовать состояния и мешать короткому замыканию до накопления достаточных данных. obj::method захватывает конкретный объект в момент создания ссылки, а Type::instanceMethod получает объект первым аргументом.

Вопрос 13 из 25

Какое утверждение о механизме «Тестирование и диагностика» верно в контексте раздела «Лямбды и функциональные интерфейсы»?

Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, andThen — позже. Функциональный код проще тестировать, если лямбды чисты, детерминированы и вынесены из инфраструктурного контекста. Лямбда может захватывать локальную переменную, только если она объявлена final или остаётся фактически неизменяемой. Ссылка на метод — сокращённая форма совместимой лямбды; вид ссылки определяет, где берётся получатель. Optional прежде всего предназначен для возвращаемого значения, когда отсутствие — нормальная часть контракта.

Вопрос 14 из 25

Каков точный результат выполнения или компиляции фрагмента из раздела «Лямбды и функциональные интерфейсы» по теме «Ссылки на методы»?

java.util.function.ToIntFunction<String> len = String::length;
System.out.println(len.applyAsInt("java"));

String::length совместима с ToIntFunction<String> и вызывает length у переданного аргумента. Integer::length совместима с ToIntFunction<String> и вызывает length у переданного аргумента. String::length совместима с ToIntFunction<Integer> и вызывает length у переданного аргумента. Лямбда с LocalDateTime.now внутри делает тест зависимым от часов и границы секунды. map(User::email), где email возвращает Optional<String>, создаёт Optional<Optional<String>>.

Вопрос 15 из 25

Как поведёт себя фрагмент по теме «Захват переменных» при разборе раздела «Лямбды и функциональные интерфейсы»?

int sum = 0;
java.util.List.of(1,2,3).forEach(x -> System.out.println(sum + x));
sum++;

Для пустой строки второй предикат не вызывается, потому что первый уже вернул false. Лямбда с LocalDateTime.now внутри делает тест зависимым от часов и границы секунды. Код не компилируется: после изменения sum переменная перестаёт быть фактически неизменяемой и не может захватываться лямбдой. После изменения исходного списка содержимое объекта тоже меняется, потому что конструктор сохранил ту же ссылку. String::length совместима с ToIntFunction<String> и вызывает length у переданного аргумента.

Вопрос 16 из 25

Как поведёт себя фрагмент по теме «Тестирование и диагностика» при разборе раздела «Лямбды и функциональные интерфейсы»?

java.util.function.Supplier<String> token = () ->
    java.time.LocalDateTime.now().toString();
System.out.println(token.get());

String::length совместима с ToIntFunction<String> и вызывает length у переданного аргумента. Код не компилируется: после изменения sum переменная перестаёт быть фактически неизменяемой и не может захватываться лямбдой. peek ничего не печатает без терминальной операции, потому что конвейер не запускается. Лямбда с LocalDateTime.now внутри делает тест зависимым от часов и границы секунды. Лямбда с Instant.now внутри делает тест зависимым от часов и границы секунды.

Вопрос 17 из 25

Как лучше исправить или прояснить поведение темы «Ссылки на методы» в разделе «Лямбды и функциональные интерфейсы»?

// Фрагмент на ревью
java.util.function.ToIntFunction<String> len = String::length;
System.out.println(len.applyAsInt("java"));

Передать Clock или функцию получения времени как зависимость. Оставлять ссылку на метод, когда получатель и аргументы очевидны; иначе явная лямбда читается лучше. Использовать reduce/collect или изменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Выбирать compose или andThen по направлению потока данных и закреплять порядок тестом на функциях, для которых перестановка меняет результат. Добавить тест защитной копии до и после создания объекта, а также при возврате значения методом доступа.

Вопрос 18 из 25

Что произойдёт с кодом по теме «Предикаты» в разделе «Лямбды и функциональные интерфейсы»?

java.util.function.Predicate<String> nonEmpty = s -> !s.isEmpty();
java.util.function.Predicate<String> longEnough = s -> s.length() > 3;
System.out.println(nonEmpty.and(longEnough).test(""));

peek ничего не печатает без терминальной операции, потому что конвейер не запускается. plusOne.andThen(timesTwo) для 3 даёт 8, а compose дал бы 7. Для пустой строки второй предикат не вызывается, потому что первый уже вернул false. Для пустой строки второй предикат не вызывается, потому что первый уже вернул true. Для пустой строки второй предикат не вызывается, потому что последний уже вернул false.

Вопрос 19 из 25

Что нужно отдельно проверить на границе контракта «Ссылки на методы» в разделе «Лямбды и функциональные интерфейсы»?

Стек вызовов лямбд может содержать синтетические имена, поэтому полезны короткие именованные методы для важных этапов. Поле объекта можно менять из лямбды, но это не делает операцию потокобезопасной. obj::method захватывает конкретный объект в момент создания ссылки, а Type::instanceMethod получает объект первым аргументом. Function.identity возвращает тот же объект, а не копию. map не вызывает функцию для пустого Optional и превращает null, возвращённый преобразователем, в пустой Optional.

Вопрос 20 из 25

Что важно учитывать при применении механизма «Тестирование и диагностика» из раздела «Лямбды и функциональные интерфейсы» в рабочем проекте?

Правильная терминальная операция делает намерение явным, но один гигантский collect часто хуже нескольких понятных этапов. Ограничение локальных переменных уменьшает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Композиция полезна для небольших чистых этапов, но не заменяет обработку ошибок и контекстные сообщения. Инъекция функции делает код гибким, но публичный API из десятков параметров-функций может стать труднее обычного объекта стратегии. Композиция правил уменьшает дублирование, но длинная цепочка без названий скрывает причину отказа.

Вопрос 21 из 25

Какой инженерный компромисс характерен для темы «Захват переменных» в разделе «Лямбды и функциональные интерфейсы»?

Ограничение локальных переменных увеличивает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Композиция правил уменьшает дублирование, но длинная цепочка без названий скрывает причину отказа. Ограничение локальных переменных уменьшает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Композиция полезна для небольших чистых этапов, но не заменяет обработку ошибок и контекстные сообщения. Final уменьшает число переназначений и помогает рассуждать о коде, но глубокая неизменяемость требует контроля всего графа объектов.

Вопрос 22 из 25

Какая правка точнее всего устраняет причину проблемы по теме «Функциональные преобразования» в разделе «Лямбды и функциональные интерфейсы»?

// Фрагмент на ревью
java.util.function.Function<Integer,Integer> plusOne = x -> x + 1;
java.util.function.Function<Integer,Integer> timesTwo = x -> x * 2;
System.out.println(plusOne.andThen(timesTwo).apply(3));

Выбирать compose, когда сначала должна выполниться текущая функция, а затем переданная. Выбирать compose или andThen по направлению потока данных и закреплять порядок тестом на функциях, для которых перестановка меняет результат. Выбирать collect для изменяемого результата, reduce — для ассоциативного свёртывания значений. Оставлять ссылку на метод, когда получатель и аргументы очевидны; иначе явная лямбда читается лучше. Выбирать andThen, когда переданная функция должна выполниться раньше текущей.

Вопрос 23 из 25

Что нужно отдельно проверить на границе контракта «Захват переменных» в разделе «Лямбды и функциональные интерфейсы»?

// Минимальный пример
class Counter {
    int total = 0;
    void addAll() {
        java.util.List.of(1, 2, 3).forEach(x -> total += x);
        System.out.println(total);
    }
}

Predicate.not удобен для отрицания, но не превращает null-небезопасную проверку в безопасную. Поле объекта можно менять из лямбды, но это не делает операцию потокобезопасной. Стек вызовов лямбд может содержать синтетические имена, поэтому полезны короткие именованные методы для важных этапов. Final-поле должно быть присвоено в объявлении, инициализаторе или каждом конструкторе. Function.identity возвращает тот же объект, а не копию.

Вопрос 24 из 25

Какое правило Java действует для темы «Предикаты» в разделе «Лямбды и функциональные интерфейсы»?

Predicate<T> принимает T и возвращает boolean; методы and и or используют короткое замыкание. Промежуточные операции вычисляются по требованию и могут объединяться поэлементно. Функциональный код проще тестировать, если лямбды чисты, детерминированы и вынесены из инфраструктурного контекста. Function<T,R> преобразует T в R; compose выполняет переданную функцию раньше, andThen — позже. Predicate<T> принимает T и не возвращает boolean; методы and и or используют короткое замыкание.

Вопрос 25 из 25

Как точнее оценить пользу и цену решения по теме «Ссылки на методы» в разделе «Лямбды и функциональные интерфейсы»?

Цепочка flatMap хорошо описывает зависимые поиски, но длинная последовательность может скрыть причину отсутствия. Композиция полезна для небольших чистых этапов, но не заменяет обработку ошибок и контекстные сообщения. Ограничение локальных переменных уменьшает гонки и неясный жизненный цикл, хотя для накопления нужен иной приём. Композиция правил уменьшает дублирование, но длинная цепочка без названий скрывает причину отказа. Ссылка короче, но перегруженные методы могут сделать вывод типов неоднозначным.

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу