что такое функциональный интерфейс java
Функциональные интерфейсы Java
Термин функциональный интерфейс был введен в Java 8. Это интерфейс, который содержит только один абстрактный (не реализованный) метод. Может содержать стандартные и статические, которые имеют реализацию, в дополнение к одному нереализованному.
Вышеуказанное содержит только один метод, и этот метод не имеет реализации.
Обычно интерфейс не содержит реализации методов, которые он объявляет, но он может содержать реализации в методах по умолчанию или в статических. Ниже приведен еще один пример с реализациями некоторых методов:
Вышеупомянутый интерфейс все еще считается функциональным, поскольку он содержит только один не реализованный метод.
Реализация с помощью лямбда-выражения
Лямбда-выражение реализует единственный метод из интерфейса. Чтобы узнать, какой метод реализует лямбда-выражение, интерфейс может содержать только один не реализованный метод. Другими словами, он должен быть функциональным.
Встроенные функциональные интерфейсы
Есть разработанные виды для часто встречающихся вариантов использования, поэтому вам не нужно создавать свои собственные функциональные интерфейсы для каждого небольшого варианта использования.
Function
Интерфейс Function interface(java.util.function.Function) является одним из самых центральных функциональных интерфейсов. Представляет функцию (метод), которая принимает один параметр и возвращает одно значение. Вот как выглядит определение:
Интерфейс Function на самом деле содержит несколько дополнительных методов в дополнение к методам, перечисленным выше, но, поскольку все они поставляются с реализацией по умолчанию, вам не нужно реализовывать их.
Единственный метод, который необходимо реализовать для реализации интерфейса Function, – это apply(). Вот пример реализации функции:
В этой реализации функции реализован метод apply(), поэтому он принимает параметр Long в качестве параметра и возвращает Long. Вот пример использования вышеупомянутого класса AddThree:
Вы также можете реализовать Function с помощью лямбда-выражения:
Как видите, реализация Function теперь встроена в объявление переменной adderLambda, а не в отдельный класс. Это немного короче, плюс мы можем видеть непосредственно в приведенном выше коде, что он делает.
Predicate
Интерфейс Java Predicate, java.util.function.Predicate, представляет простую функцию, которая принимает одно значение в качестве параметра и возвращает true или false:
Интерфейс Predicate содержит больше методов, чем метод test(), но остальные являются стандартными или статическими, которые вам не нужно реализовывать.
Вы можете реализовать Predicate, используя класс, например так:
Вы также можете реализовать Predicate, используя лямбда-выражение:
Эта лямбда-реализация Predicate фактически делает то же самое, что и реализация выше, использующая класс.
UnaryOperator
Интерфейс Java UnaryOperator представляет операцию, которая принимает один параметр и возвращает параметр того же типа:
Интерфейс UnaryOperator может использоваться для представления операции, которая принимает конкретный объект в качестве параметра, изменяет этот объект и возвращает его снова – возможно, как часть цепочки обработки функционального потока.
BinaryOperator
BinaryOperator – это функциональный интерфейс, представляющий операцию, которая принимает два параметра и возвращает одно значение. Оба параметра и тип возвращаемого значения должны быть одного типа. Полезен при реализации функций, которые суммируют, вычитают, делят, умножают и т. д. Два элемента одного типа и возвращают третий элемент того же типа.
Supplier
Интерфейс Supplier – это функциональный интерфейс, представляющий функцию, которая предоставляет значение некоторых видов. Также можно рассматривать как фабричный интерфейс:
Эта реализация Java Supplier возвращает новый экземпляр Integer со случайным значением от 0 до 1000.
Consumer
Consumer – это функциональный интерфейс, представляющий функцию, которая потребляет значение без возврата какого-либо значения. Реализация может распечатывать значение или записывать его в файл, или по сети и т. д. Реализация:
Функциональные интерфейсы и лямбда-выражения в Java
Что это такое, зачем нужно и как работает.
Вы наверняка знакомы с ситуацией, когда в разных частях программы должен выполняться один и тот же код, а различие лишь в данных, которые он будет обрабатывать. И тогда кусок кода не дублируют, а поступают хитрее — создают метод. И этот метод вызывают в нужных местах.
Передача простых параметров в виде примитивов или объектов труда обычно не составляет. Но порой в метод требуется передавать не просто переменную, а исполняемый код.
Например, нам нужен метод, который работает с элементами массива, причём только с теми, что соответствуют некоторому условию. А само условие во время написания метода мы можем не знать (или оно будет меняться).
Как поступить? Передавать реализующий условие код с помощью параметра метода! Да, в Java начиная с восьмой версии можно подобное делать. И сейчас вы узнаете как.
Хлебом не корми — дай кому-нибудь про Java рассказать.
Пример
Напишем методы, возвращающие сумму и произведение двух чисел:
А теперь объединим их в один — processTwoNumbers. Он будет принимать два параметра-числа и код, который их обрабатывает.
private int processTwoNumbers ( int a, int b, [сюда передаётся код])
Для выполнения метода sum третий параметр примет в качестве аргумента действие a+b, а для выполнения метода mult — a*b.
Обратите внимание, что третьим аргументом может быть передан не любой код, а только тот, который принимает на вход два параметра заданного типа (у нас int) и возвращает переменную нужного типа ( int).
Значит, надо как-то сообщить об этом компилятору — запретить будущим разработчикам передавать неподходящий код (вроде a+b+c).
Поможет в этом сигнатура метода. Она станет третьим параметром в нашем методе processTwoNumbers:
private int processTwoNumbers ( int a, int b, [сигнатура метода])
Но как записать третий параметр, чтобы сигнатура самого метода processTwoNumbers не разрослась до нечитабельности? Этот вопрос разработчики Java решили изящно. Они придумали функциональные интерфейсы.
Что такое функциональный интерфейс
Функциональный интерфейс — это интерфейс, который содержит ровно один абстрактный метод, то есть описание метода без тела. Статические методы и методы по умолчанию при этом не в счёт, их в функциональном интерфейсе может быть сколько угодно.
Когда параметром метода является функциональный интерфейс, при вызове этого метода одним из аргументов должен быть блок кода.
Передаваемый блок кода должен удовлетворять следующему условию: его сигнатура должна совпадать с сигнатурой единственного абстрактного метода функционального интерфейса.
Звучит непросто, поясним на примере:
Важно. В Java есть несколько готовых функциональных интерфейсов с разным числом и типами входных-выходных параметров. (Как раз из таких ToIntBiFunction выше.) А если мы создаём новый функциональный интерфейс, то важно не забыть аннотацию @FunctionalInterface. Увидев её, компилятор проверит, что интерфейс и правда является функциональным.
Функциональный интерфейс ToIntBiFunction подходит к тому примеру, с которого мы начинали. Это значит, что мы можем передать в него аргументом код, который:
Кусочек ToIntBiFunction говорит: передавай сюда метод с такой же сигнатурой, как у метода внутри меня.
Чтобы внутри метода processTwoNumbers выполнить переданный код, нужно вызвать метод из функционального интерфейса:
Вот мы и добрались до лямбда-выражений.
Что такое лямбда-выражения
Это компактный синтаксис, заимствованный из λ-исчисления, для передачи кода в качестве параметра в другой код.
По сути, это анонимный (без имени) класс или метод. Так как всё в Java (за исключением примитивных типов) — это объекты, лямбды тоже должны быть связаны с конкретным объектным типом. Как вы догадались, он называется функциональным интерфейсом.
То есть лямбда-выражение не выполняется само по себе, а нужно для реализации метода, который определён в функциональном интерфейсе.
Не будь лямбд, вызывать метод processTwoNumbers каждый раз приходилось бы так:
Примечание. biFunction в примере создана с использованием анонимных классов. Без этого нам пришлось бы создавать класс, реализующий интерфейс ToIntBiFunction, и объявлять в этом классе метод applyAsInt. А с анонимным классом мы всё это сделали на лету.
В примере выше всё, кроме одной строчки, избыточно. За содержательную часть (логику работы) отвечает только одно выражение return a + b, а всё остальное — техническая шелуха. И её пришлось написать многовато, даже чтобы просто передать методу код сложения двух чисел.
Здесь и вступают в игру лямбды. С ними можно сократить создание biFunction всего до десяти символов!
А наша лямбда будет такой:
И всё! Этот блок из 10 символов можно передавать как аргумент методу, ожидающему функциональный интерфейс в качестве параметра. Причём чаще всего обходятся без промежуточной переменной — передают напрямую лямбду:
Компилятор проверит, что лямбда подходит функциональному интерфейсу — принимает нужное число параметров нужного типа. Напомню, в нашем примере задействован функциональный интерфейс ToIntBiFunction. Сигнатура его единственного абстрактного метода содержит два параметра ( Integer a, Integer b).
Например, такой вот вызов метода не скомпилируется, потому что передан всего один параметр:
Лямбды записывают по-разному. Мы рассмотрели только один вариант.
Где применяют лямбды?
Много где. Довольно частый случай — обход элементов в цикле:
Ещё лямбды работают в компараторах при сортировке. Допустим, нужно отсортировать коллекцию по последней букве каждого слова:
Редко обходятся без лямбд при работе с коллекциями вместе со Stream API. В следующем примере фильтруем стрим по значению ( filter), меняем каждый элемент ( map) и собираем в список ( collect):
Подытожим
Функциональные интерфейсы в Java 8 избавили разработчиков от чудовищно громоздкого синтаксиса с анонимными классами (когда требовалось передавать некую функциональность в метод) и позволили использовать компактные лямбда-выражения и ссылки на методы.
Сперва синтаксическим сахаром были функциональные интерфейсы, они позволили оперировать блоком кода, который выполняется когда нужно, но реализации были слишком громоздкими. А с лямбдами функциональные интерфейсы стали записываться короче. Так что лямбды — не просто синтаксический сахар, а синтаксический сахар синтаксического сахара.
Теперь на Java можно писать программы в стиле функциональных языков программирования (это когда программа записывается как последовательное применение функций к некоторым значениям и другим функциям, а не как сложная структура из циклов, условных операторов и перекладывания значений туда-сюда). Удивительно, как легко превратить массивные структуры кода в изящные цепочки вызовов, и всё это благодаря лямбдам и функциональным интерфейсам.
Официальная документация по лямбдам здесь.
Компаратор (от англ. compare, «сравнивать») — функция, которая принимает на вход два элемента, сравнивает их и отвечает: больше/меньше/равно.
От англ. syntactic sugar — это избыточные синтаксические возможности языка программирования, придуманные только для удобства.