Лямбда-выражения это безымянная функция с параметрами и телом.

Тело лямбда-выражение может быть оператором блока или выражение.

->

Отделяет параметры и тело.

(int х) -> х + 1

принимает параметр Int и возвращает значение параметра увеличивается на 1.

(int х, у int) -> х + у

принимает два параметра целочисленные и возвращает сумму.

(String str) -> {System.out.println (str);}

принимает параметр типа String и производит его вывод в консоль.

str-> System.out.println (str)

принимает параметр и выводит его в консоль. Он аналогичен приведенному выше коду.

() -> "nookery.ru"

не принимает никаких параметров и возвращает строку.

(String str) -> str.length ()

принимает параметр типа String и возвращает его длину.

Следующий лямбда принимает два параметра целочисленные и возвращает максимальное из двух.

(int x, int y)  ->  {  
    int max = x  > y  ?  x  : y;
    return max;
}

Почему лямбда-выражения

Выражения лямбда позволяет нам передать логику в компактном виде.

Следующий код использует анонимный внутренний класс, чтобы добавить обработчик событий для действия нажатия кнопки.

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { 
       System.out.println("nookery.ru");
    }
});

Обработчик действия печатает сообщение в консоль, когда эта кнопка нажата.

С помощью лямбда-выражения мы можем добавить обработчик действий на события нажатия кнопки в одной строке кода.

button.addActionListener (е -> System.out.println ( "nookery.ru"));

Java Лямбда Синтаксис

Общий синтаксис для использования лямбда-выражений

(Параметры) -> {тело}

->

Отделяет параметры и лямбда — выражения тела.

Параметры заключены в круглые скобки, которые таким же образом, как для методов в то время как тело лямбда-выражение представляет собой блок кода, заключенный в фигурные скобки.

Выражение тела лямбда может иметь локальные переменные, операторы. Мы можем использовать перерыв, продолжить, и вернуться в лямбда-выражения тела. Мы можем даже выбросить исключения из выражения тела лямбда.

Лямбда-выражение не имеет имени, так как он представляет собой анонимный внутренний класс.

Тип возвращаемого значения лямбда-выражения выводится компилятором.

Лямбда-выражение не может иметь броски пункт как метод.

Лямбда-выражение не может быть общим, а родовое определяется в функциональном интерфейсе.

Явные и неявные лямбда-выражения

Лямбда-выражения, которое не декларирует тип, присвоенные его параметров, называется неявным лямбда-выражения.

Явное выражение лямбда лямбда-выражение, которое объявляет тип его параметров.

В примере ниже я написал, следующий код который создает интерфейс с одним методом и использует его в качестве типа лямбда — выражения. При создании лямбда — выражения мы объявляем тип параметра x1, чтобы иметь тип Integer.

public class test {

  public static void main(String[] args) {
    MyCalc calc = (Integer x1) -> x1 * 2;

    System.out.println("Вычисляем 5*2= " + MyCalc.calc(5));

  }
}
interface MyCalc{

  public Integer calc(Integer x1);

}

Результатом выполнения программы будет:   Вычисляем 5*2=10

Во втором примере я снова не использовал явно тип, но компилятор меня все равно понимает что я хочу.

public class test {

  public static void main(String[] args) {
    MyCalc calc = (x1) -> x1 * 2;

    System.out.println("Вычисляем 5*2=" +MyCalc.calc(5));

  }
}
interface MyCalc {

  public Integer calc(Integer x1);

}

Пропускаем указание типа параметров

Мы можем выбрать, чтобы исключить типы параметров в лямбда-выражений.

В лямбда — выражения

(int x, int y) -> { return x + y; }

Типы параметров объявляются.

Мы можем смело переписать лямбда-выражения, опуская типы параметров, как в примере ниже.

(x, y) -> { return x + y; }

Если мы решили опустить типы параметров, мы должны опустить типы для всех параметров.

public class  test {
  public static void main(String[] args) {
    Site stringSite = (str) -> str.length();
    String name ="java-soft.ru";
    int result = stringSite.getStr(name);
    System.out.println(result);

  }
}

@FunctionalInterface
interface Site {
int getStr(String str);
}

Результат выполнения программы будет: 12

Single Параметр

Для одного выражения параметра лямбда мы можем пропустить скобки, как мы пропускаем явно тип параметра.

Лямбда — выражения

(String msg) -> {System.out.println(msg);}

Тогда мы можем опустить тип параметра, чтобы иметь

(str) -> {System.out.println (str);}

Далее мы можем опустить тип параметра и круглые скобки следующим образом.

(str)->{System.out.println(str);}

public class  test {
  public static void main(String[] args) {
    Site stringSite = str -> str.length();
    String name ="java-soft.ru";
    int result = stringSite.getStr(name);
    System.out.println(result);

  }
}

@FunctionalInterface
interface Processor {
int getStr(String str);
}

Результат будет тот же 12.

Нет Параметры

Для лямбда-выражения без параметров, мы по-прежнему можем нуждаются в том что бы ставить круглые скобки.

() -> { System.out.println("nookery.ru"); }

В следующем примере показано , как использовать BooleanSupplier .

import java.util.function.BooleanSupplier;

public class test {
  public static void main(String[] args) {
    BooleanSupplier bool = () -> true;
    System.out.println(bool.getAsBoolean());

    int x = 0, y= 1;
    bool = () -> x > y;
    System.out.println(bool.getAsBoolean());
  }
}

Результатом выполнения программы будет: true; false;

Модификатор final

Вы можете использовать final модификатор в объявлении параметра явных лямбда — выражений.

Следующие выражения лямбда использовать конечный модификатор.

(final int x, final int y) -> { return x + y; }

Мы можем использовать только один модификатор следующим образом.

(int x, final int y) -> {return x + y;}

public class test {
  public static void main(String[] args) {
    Site stringSite = (final String str) -> str.length();
    String name = "nookery.ru";
    int result = stringSite.getLen(name);
    System.out.println(result);

  }
}

@FunctionalInterface
interface Site {
  int getLen(String str);
}

Результатом выполнения программы будет: 12;

Лямбда-выражения для тела

Телом лямбда-выражение может быть оператором блока или одно выражение.

Если оператор блока заключен в скобки,  одновременно одно выражение может существовать без скобок.

В блоке возвращения мы можем использовать return оператор для возврата значения.

Следующее выражение лямбда использует оператор блока и использует return оператор , чтобы вернуть сумму.

int x, int y) -> { return x + y; }

В то время как следующее лямбда использует выражение:

(int x, int y) -> x + y

Выражение не требует фигурных скобок.

Лямбда не нужно возвращать значение. Следующие два лямбда-выражения просто выводят в консоль и ничего не возвращают.

(String str) -> {System.out.println (str);} // блок-заявление
(String str) -> System.out.println (str) // выражение

Пример:

public class test {
  public static void main(String[] argv) {
    Site stringSite = (String str) -> str.length();
    String name = "nookery.ru";
    int result = stringSite.getLen(name);
    System.out.println(result);

  }
}

@FunctionalInterface
interface Site {
  int getLen(String str);
}

Результатом выполнения программы будет: 12