Что такое лямбда выражение в java
Обновлено: 18.05.2024
Это анонимные методы (методы без имени), используемые для реализации метода, определенного функциональным интерфейсом. Важно знать, что такое функциональный интерфейс, прежде чем вы начнете использовать Лямбда-выражения.
Функциональный интерфейс
Функциональный интерфейс — это интерфейс, содержащий один и только один абстрактный метод.
Если вы посмотрите на определение стандартного интерфейса Runnable , то вы заметите как он попадает в определение функционального интерфейса, поскольку он определяет только один метод: run().
В приведенном ниже примере кода метод computeName является абстрактным и единственным методом в интерфейсе MyName, что делает его функциональным интерфейсом.
interface MyName String computeName(String str);
>
Оператор Стрелка
Лямбда-выражения вводят новый оператор стрелка -> в Java. Он разделяет лямбда-выражение на 2 части:
В левой части задаются параметры, необходимые для выражения. Эта часть может быть пустой если не требуется никаких параметров.
Правая сторона — это тело выражения, которое определяет его действия.
Теперь, используя функциональные выражения и оператор стрелки можно составить просто лямбда-выражение:
interface NumericTest boolean computeTest(int n);
>
interface MyGreeting String processName(String str);
>
public static void main(String args[]) MyGreeting morningGreeting = (str) -> "Good Morning " + str + "!";
MyGreeting eveningGreeting = (str) -> "Good Evening " + str + "!";
// Output: Good Morning Luis!
System.out.println(morningGreeting.processName("Luis"));
// Output: Good Evening Jessica!
System.out.println(eveningGreeting.processName("Jessica"));
>
Переменные morningGreeting и eveningGreeting в строках 6 и 7 соответственно в примере выше создают ссылку на интерфейс MyGreeting и определяют 2 выражения приветствия.
При написании лямбда-выражения можно явно указать тип параметра, как это делается в примере ниже:
MyGreeting morningGreeting = (String str) -> "Good Morning " + str + "!";
MyGreeting eveningGreeting = (String str) -> "Good Evening " + str + "!";
Блок Лямбда-выражений
До сих пор я рассматривал одиночные лямбда-выражения. Существует еще один тип выражения, когда справа от оператора стрелки находится не одно простое выражение и так называемый блок лямба :
interface MyString String myStringFunction(String str);
>
public static void main (String args[]) // Block lambda to reverse string
MyString reverseStr = (str) -> String result = "";
// Output: omeD adbmaL
System.out.println(reverseStr.myStringFunction("Lambda Demo"));
>
Функциональные интерфейсы generic
Лямбда-выражения не могут быть generic, но функциональный интерфейс, связанный с выражением, может. Можно написать один общий интерфейс и возвращать различные типы данных, например:
interface MyGeneric T compute(T t);
>
public static void main(String args[])
// String version of MyGenericInteface
MyGeneric reverse = (str) -> String result = "";
// Integer version of MyGeneric
MyGeneric factorial = (Integer i) -> int result = 1;
int n = 5;
for(int i=1; i // Output: omeD adbmaL
System.out.println(reverse.compute("Lambda Demo"));
Использование Лямбда-выражений в качестве аргументов
Одно распространенное использование лямбда — передача их в качестве аргументов.
Вы можете передавать исполняемый код аргументам методов в качестве параметров. Для этого просто убедитесь, что тип функционального интерфейса совместим с требуемым параметром.
interface MyString String myStringFunction(String str);
>
public static String reverseStr(MyString reverse, String str) return reverse.myStringFunction(str);
>
public static void main (String args[]) // Block lambda to reverse string
MyString reverse = (str) -> String result = "";
// Output: omeD adbmaL
System.out.println(reverseStr(reverse, "Lambda Demo"));
>
Эти концепции дадут вам хорошую основу для начала работы с лямбда-выражениями. Взгляните на свой код и посмотрите, где вы можете их использовать.
Первый метод простой — выдача всех адресов. Но другие методы сложнее, например:
Каждый раз надо придумывать новые имена, писать новые методы. Может это и не так сложно, но суть в том, что можно сделать проще с помощью лямбда-выражений.
Заметьте, что во всех вышеприведенных примерах мы используем какое-то условие,а значит можно написать функцию, которая возвращает boolean и ее передавать.
Именно здесь и можно применить лямбда-выражение — это блок кода, описывающий функцию интерфейса; функция эта передается как параметр в метод и вызывается при надобности (в нашем случае в тот момент, когда надо проверить условие см. функцию filter.test()).
В нашем случае код с лямбда-выражением будет выглядеть так, что вместо четырех методов появится один, принимающий условие как аргумент:
А уж при вызове метода мы будем передавать лямбда-выражение:
Выше мы получили все электронные адреса.
Аналог — анонимный класс
Лямбда выражения — это не что-то принципиально новое, появившееся в Java 8, а просто синтаксический сахар для анонимного класса. Раньше бы вместо вышеприведенного лямбда-выражения в параметр бы передавалась вот такая громоздкая конструкция:
Выглядит страшно, поэтому распространение получили такие вещи с Java 8 именно благодаря сахару.
В лямбда-выражениях можно опускать слово return и точку с запятой, если правая часть состоит из одной строки. Также, не нужно указывать типы параметров, обычно компилатор их определяет из кода.
В аргументе getEmail() мы передаем интерфейс Predicate. Но как компилятор определяет, какой именно метод интерфейса передается?
Немного о функциональных интерфейсах
Predicate — это функциональный интерфейс, что означает, что он состоит только из одного метода (не считая статических и методов по умолчанию). Этот метод и вызывается для тестирования нашего условия. Мы можем передавать непосредственно содержимое этого метода, не указывания его имени. Компилятор и так догадается, что это за метод, поскольку в интерфейсе Predicate он всего один:
Если бы из было два, то компилятор выдал бы ошибку. Лямбда-выражение можно передавать, только если оно реализует метод функционального интерфейса.
Обратите внимание, что функциональный интерфейс помечен аннотацией @FunctionalInterface. Она нужна прежде всего для разработчика, потому что и без этой аннотации любой интерфейс с единственным методом может служить лямбда-выражением. Просто другие разработчики, видя аннотацию, сразу поймут, что интерфейс не предполагает добавления новых методов.
Еще раз: поскольку метод единственный, и не надо уточнять его название, можно передать в параметр типа Predicate саму реализацию метода и аргумент. Idea сама предлагает заменить такой навороченный участок кода кратким лямбда-выражением.
При этом необязательно использовать интерфейс Predicate, можно создать свой интерфейс с другим названием, но такой же сигнатурой метода. Пример будет работать, просто Predicate уже есть в jdk, и плодить другие интерфейсы не рекомендуется для чистоты кода.
Допишем остальные методы
Допишем вызовы с лямбда-выражениями оставшихся двух методов.
Этот получает электронные адреса из группы1:
Подробнее о функциональных интерфейсах
Теперь закрепим идею функционального интерфейса. Как вы уже поняли из предыдущего примера, это интерфейс, который содержит ровно один абстрактный (в смысле не реализованный метод).
Вот примеры, угадайте является ли следующий интерфейс функциональным:
Ответ нет, в интерфейсе Movable нет ни одного абстрактного метода, а надо один.
Ответ да, в интерфейсе Runnable ровно один метод (из Movable не наследуется ни одного).
Интерфейс FastRunnable функциональный, поскольку он наследует один метод из Runnable, а default-метод fastrun() не учитывается.
Интерфейс Swimming не является функциональным, поскольку из Movable методы не наследуются, а метод ss() статический, а значит не учитывается.
Можно поупражняться в IDE в написании интерфейсов, проверяя ответ постановкой аннотации @FunctionalInterface вверху. Если интерфейс не фукциональный, компилятор выдаст ошибку.
Например, Runnable — функциональный, а значит можно поставить аннотацию @FunctionalInterface без проблем:
Подробнее о синтаксисе лямбда-выражения
Вернемся к примеру с электронными адресами. В нем среди прочих мы использовали такое лямбда-выражение:
Выглядит оно не как полноценная функция, потому что в лямбда-выражених многие части опускаются. Вышеприведенный код эквивалентен следующему:
Слева от стрелки параметры, а справа тело метода.
Параметр метода здесь один, он имеет тип String. Возвращаемое значение тоже имеет тип String.
Это значит, что данное лямбда-выражение подойдет к любому функциональному интерфейсу, имеющему метод с одним параметром типа String и возвращающим значение такого же типа. Например, вместо встроенного в JDK 8 интерфейса Predicate мы могли бы определить и использовать любой собственный интерфейс:
Название тут не важно, лишь бы было совпадение по количеству и типам аргументов.
Но обычно предпочтительнее использовать уже существующий интерфейс, а не писать свой, тем более почти все мыслимые интерфейсы с одним и двумя аргументами в JDK 8 уже есть и являются стандартными, как мы увидим ниже.
Когда можно опустить круглые скобки
Рассмотрим внимательнее левую часть двух вышеприведенных выражений:
Краткая формаё
А это полная форма того же лямбда-выражения:
Полная форма
Во втором выражении присутствует тип аргумента и круглые скобки, а в первом нет.
Опустить круглые скобки слева можно в том и только том случае, если аргумент один, и его тип явно не задан (опущен).
Это означает, что например , если метод без аргументов, то круглые скобки должны присутствовать.
Вот примеры корректно написанных лямбда-выпажений:
А вот примеры некорректных лямбда-выражений:
- В первом выражении задан тип, а значит нужны скобки.
- Во втором аргументов два, а не один, что означает, снова нужны скобки.
- В третьем снова два аргумента, а не один.
Фигурные скобки справа
Теперь сравним правую часть выражений, во втором выражении есть фигурные скобки <>.
Фигурные скобки дают возможность написать в правой части более одной строки кода. Но при этом нельзя опускать точку с запятой и оператор return, именно этому они во втором выражении и есть.
Как уже понятно, в первом выражении все это опущено потому, что одна строка кода позволяет все это опустить.
Приведем еще примеры корректный лямбда-выражений:
Найдите ошибки в лямбда-выражениях
А теперь некорректные, угадайте, что с ними не так:
- В первом нужны круглые скобки слева, поскольку аргументов два.
- Во втором — фигурные скобки справа.
- В третьем пропущена точка с запятой (справа).
Привильный вариант такой:
А почему некорректны вот эти выражения, еще не упоминалось:
Ошибка в том, что если хотя бы один тип параметра слева указан, то остальные тоже должны быть указаны.
Чтобы сделать выражения корректными, надо либо убрать все типы (компилятор обычно их может определить из кода, не переживайте), либо, наоборот, указать все типы:
Вот еще некорретное выражение:
Представьте его как обычный метод и поймете, что если есть аргумент а, то определять локальную переменную с тем же именем а нельзя.
Вот так будет правильно:
Ссылки на методы (Method references)
Но это еще не все, синтаксический сахар простирается дальше.
Рассмотрим случай, когда все, что мы делаем в лямбда-выражении — это вызываем другой метод. Например:
Мы передаем аргумент a в метод интерфейса Consumer (стандартный интерфейс из jdk) и ничего не возвращаем (void). Этот аргумент передается дальше в метод println, который тоже ничего не возвращает. Сигнатуры методов одинаковые — и вышеприведенного метода интерфейса Consumer, и метода println:
На всякий случай вот код метода стандартного функционального интерфейса Consumer из jdk, в нем один параметр и возвращаемый тип void:
Поскольку лямбда-выражение — это всего лишь код, описывающий входные параметры и тело метода, а входные параметры как лямбда выражения, так и метода, использованного внутри лямбда выражения одинаковые, нам достаточно указать один метод. Так что вместо такой записи:
можно использовать сокращенную запись — ссылку на метод println:
Записи (1) и (2) эквивалентны.
Стандартные функциональные интерфейсы и примеры их использования в JDK 8
Если вы хотите передать в параметр функцию, то наверняка свой функциональный интерфейс писать не придется, так как уже есть куча стандартных интерфейсов с различными сигнатурами функций.
В пакете java.util.function их целых 43.
Но запомнить надо всего шесть, остальные интерфейсы производные от остальных. Например, мы выше использовали интерфейс Predicate, который возвращает boolean и принимает один аргумент. А есть BiPredicate — он такой же, но принимает два аргумента.
Вот эти шесть интерфейсов (в третьей колонке примеры с method reference, который мы рассматривали выше):
| Интерфейс | Сигнатура | Пример из JDK |
| UnaryOperator | T apply(T t) | String::toLowerCase |
| BinaryOperator | T apply(T t1, T t2) | BigInteger::add |
| Predicate | boolean test(T t) | Collection::isEmpty |
| Function | R apply(T t) | Arrays::asList |
| Supplier | T get() | Instant::now |
| Consumer | void accept(T t) | System.out::println |
По сигнатуре методов из третьего столбца легко понять сигнатуру и предназначение методов из второго, даже не вникая в буквы T, R, поскольку эти сигнатуры одинаковы.
А название из первого поясняет суть той или иной сигнатуры.
Например, BigInteger::add — бинарный оператор.
А вот (почти) все интерфейсы из java.util.function, которые поместились на скриншот:
java.util.function
Проще зайти и посмотреть их сигнатуру, чем перечислять тут. Но они производятся по таким принципам:
- Есть дополнительные три интерфейса BiFunction, BiPredicate, BiConsumer, принимающие два аргумента, а не один, в отличие от исходных Function, Predicate, Consumer. Пример:
- Для всех интерфейсов, где это имеет смысл, есть производные с префиксом Double, Int, Long — они принимают конкретный примитивный тип, а не Generic, как исходные например:
- Для интерфейса Function помимо производных, уточняющих примитивный тип аргумента, есть производные с ..To.., уточняющие возвращаемый примитивный тип, например:
- Особняком стоит BooleanSupplier, возвращающий boolean:
Замыкания в Java
Еще один интересный (но не рекомендуемый) способ использования лямбда-выражений — это замыкания. Те, кто знает JavaScript, понимают о чем речь. Возьмем пример:
К удивлению, результат в консоли будет таким:
На первый взгляд кажется магией, ведь локальные переменные в методах живут только во время метода, а потом забываются. А тут arr[] определенно запоминается.
Но на самом деле arr[] находится не в методе, а в синтетическом final поле некоторого класса, который генерируется jvm и содержит нашу функцию () -> ++arr[0]; Так что все нормально.
Итоги
Пока итогов нет, статья будет дополняться. Исходный код некоторых примеров доступен на GitHub.
Java всегда была объектно-ориентированным языком программирования. А это означает, что все вращается вокруг объектов (за исключением некоторых примитивных типов). Любые методы и функции в Java являются частью класса, поэтому мы должны использовать класс/объект для вызова любой функции. Так что же в этот гармоничный мир привнесла Java 8?
Если мы посмотрим на такие языки программирования, как C++ , JavaScript , то они официально называются функциональными языками. Это значит, что мы можем писать функции и использовать их при необходимости. Такие языки поддерживают объектно-ориентированное программирование, а также функциональное программирование.
Но объектно-ориентированность языка не является его недостатком, однако влечет за собой написание много служебного кода. Например, нам надо создать экземпляр Runnable . Обычно в Java мы делаем это с помощью анонимных классов, как показано ниже:
Обратите внимание, нам нужно лишь то, что находится внутри метода run() . Остальной код является лишь описательной частью, особенностью написания кода на Java.
Что предлагает нам Java 8?
Java 8 вводит такое понятие, как функциональные интерфейсы и лямбда-выражения, которые призваны упростить и максимально очистить программу от бесполезного кода.
Функциональные интерфейсы
Интерфейс с одним абстрактным методом называется функциональным интерфейсом. Чтобы отметить интерфейс как функциональный, используется аннотация @FunctionalInterface . Она не является обязательной, но ее использование считается хорошим тоном программирования на Java 8. Также эта аннотация помогает избежать случайного добавления дополнительных методов.
Основным преимуществом функционального интерфейса является то, что мы можем использовать лямбда-выражения для создания экземпляра и, как следствие, избежать использования громоздких реализаций анонимного класса.
Collections API в Java 8 был полностью переписан для добавления возможности использовать функциональные интерфейсы. На данный момент в Java 8 есть множество функциональных интерфейсов, которые находятся в пакете java.util.function . Наиболее полезными для нас являются интерфейсы Consumer , Supplier , Function и Predicate . Подробнее о них читайте в нашей статье Полное руководство по Java 8 Strem API.
А теперь давайте рассмотрим некоторые рекомендации по использованию функциональных интерфейсов:
![]()
В этой статье мы рассмотрим лямбда-выражения на примере интерфейса Comparator.
1. Сортировка без лямбд
До выхода Java 8 для сортировки коллекций нам необходимо было создавать анонимный внутренний класс для Comparator.
Послее передать его в Collections.sort вместе с коллекцией.
2. Сортировка с использованием лямбд
С приходом Java 8 мы можем заменить создание анонимного наследника класса на лямбда-выражение:
что значительно короче чем предыдущий вариант.
Так же, мы можем упустить обозначение типов o1 и o2, сократив код до:
3. List.sort()
В Java 8 в интерфейс List добавили метод sort, что позволяет использовать вместо
4. Сортировка в обратном направлении
С приходом Java 8 сортировка в обратном направлении стала еще легче. Ведь изменять уже созданные Comparator-ы не нужно.
Читайте также:
