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. Использовать reduce/collect или изменяемый объект с чётким владельцем вместо изменения захваченной локальной переменной. Выбирать compose или andThen по направлению потока данных и закреплять порядок тестом на функциях, для которых перестановка меняет результат. Передать Clock или функцию получения времени как зависимость.

Вопрос 3 из 25

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

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

Вопрос 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(""));

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

Вопрос 5 из 25

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

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

Вопрос 6 из 25

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

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

Вопрос 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));

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

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

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

Вопрос 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));

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

Вопрос 11 из 25

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

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

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

Вопрос 12 из 25

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

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

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

Вопрос 13 из 25

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

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

Вопрос 14 из 25

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

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

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

Вопрос 15 из 25

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

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

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

Вопрос 16 из 25

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

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

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

Вопрос 17 из 25

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

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

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

Вопрос 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(""));

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

Вопрос 19 из 25

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

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

Вопрос 20 из 25

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

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

Вопрос 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));

Выбирать andThen, когда переданная функция должна выполниться раньше текущей. Выбирать compose, когда сначала должна выполниться текущая функция, а затем переданная. Оставлять ссылку на метод, когда получатель и аргументы очевидны; иначе явная лямбда читается лучше. Выбирать collect для изменяемого результата, reduce — для ассоциативного свёртывания значений. Выбирать compose или 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);
    }
}

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

Вопрос 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-страницу