简介

虽然看着很先进，其实Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用,因为这就和某些很高级的黑客写的代码一样,简洁,难懂,难以调试,维护人员想骂娘,所以说看公司和项目组

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。

语法：

(parameters) -> expression
或
(parameters) ->{ statements; }


以下是lambda表达式的重要特征:

• **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。

• **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。

• **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。

• **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

Lambda表达式实例

Lambda 表达式的简单例子:

// 1. 不需要参数,返回值为 5  
() -> 5
 
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
 
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
 
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
 
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)


文件输入以下代码：

package com.example.javademo.test;

/**
* @program: test
* @description: 测试
* @author: liulq
* @create: 2022-01-04 22:00
*/
publicclass Day {
   public static void main(String[] args) {
       Day day = new Day();
       // 类型声明
       MathOperation addition = (int a, int b) -> a + b;

       // 不用类型声明
       MathOperation subtraction = (a, b) -> a - b;

       // 大括号中的返回语句
       MathOperation multiplication = (int a, int b) -> {
           return a * b;
       };

       // 没有大括号及返回语句
       MathOperation division = (int a, int b) -> a / b;

       System.out.println("10 + 5 = " + day.operate(10, 5, addition));
       System.out.println("10 - 5 = " + day.operate(10, 5, subtraction));
       System.out.println("10 x 5 = " + day.operate(10, 5, multiplication));
       System.out.println("10 / 5 = " + day.operate(10, 5, division));

       // 不用括号
       GreetingService greetService1 = message ->
               System.out.println("Hello " + message);

       // 用括号
       GreetingService greetService2 = (message) ->
               System.out.println("Hello " + message);

       greetService1.sayMessage("Runoob");
       greetService2.sayMessage("Google");
   }

   interface MathOperation {
       int operation(int a, int b);
   }

   interface GreetingService {
       void sayMessage(String message);
   }

   private int operate(int a, int b, MathOperation mathOperation) {
       return mathOperation.operation(a, b);
   }

}



控制台：

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google


使用 Lambda 表达式需要注意以下两点：

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。

• Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

文件输入以下代码：

publicclass Java8Tester {

  finalstatic String salutation = "Hello! ";
 
  public static void main(String args[]){
     GreetingService greetService1 = message ->
     System.out.println(salutation + message);
     greetService1.sayMessage("Runoob");
  }
   
  interface GreetingService {
     void sayMessage(String message);
  }
}


控制台：

javac Java8Tester.java
java Java8Tester
Hello! Runoob


我们也可以直接在 lambda 表达式中访问外层的局部变量：

publicclass Java8Tester {
   public static void main(String args[]) {
       finalint num = 1;
       Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
       s.convert(2);  // 输出结果为 3
   }

   publicinterface Converter<T1, T2> {
       void convert(int i);
   }
}


lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

int num = 1;  
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;  
//报错信息：Local variable num defined in an enclosing scope must be final or effectively
final


在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

demo

假设有一个玩家List ,程序员可以使用 for 语句 ("for 循环")来遍历,在Java SE 8中可以转换为另一种形式:

package com.example.javademo.test;

import java.util.Arrays;
import java.util.List;

/**
* @program: test
* @description: 测试
* @author: liulq
* @create: 2022-01-04 22:16
*/
publicclass Day2 {
   public static void main(String[] args) {
       String[] atp = {"Rafael Nadal", "Novak Djokovic",
               "Stanislas Wawrinka",
               "David Ferrer", "Roger Federer",
               "Andy Murray", "Tomas Berdych",
               "Juan Martin Del Potro"};
       List<String> players = Arrays.asList(atp);

// 以前的循环方式
       for (String player : players) {
           System.out.print(player + "; ");
       }

// 使用 lambda 表达式以及函数操作(functional operation)
       players.forEach((player) -> System.out.print(player + "; "));

// 在 Java 8 中使用双冒号操作符(double colon operator)
       players.forEach(System.out::println);
   }
}



正如您看到的,lambda表达式可以将我们的代码缩减到一行。 另一个例子是在图形用户界面程序中,匿名类可以使用lambda表达式来代替。 同样,在实现Runnable接口时也可以这样使用:

// 使用匿名内部类  
btn.setOnAction(new EventHandler<ActionEvent>() {  
         @Override
         public void handle(ActionEvent event) {  
             System.out.println("Hello World!");  
         }  
   });  
 
// 或者使用 lambda expression  
btn.setOnAction(event -> System.out.println("Hello World!"));  


下面是使用lambdas 来实现 Runnable接口 的示例:

package com.example.javademo.test;

/**
* @program: test
* @description:
* @author: liulq
* @create: 2022-01-04 22:18
*/
publicclass Day3 {
   public static void main(String[] args) {
       // 1.1使用匿名内部类
       new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("Hello world !");
           }
       }).start();

// 1.2使用 lambda expression
       new Thread(() -> System.out.println("Hello world !")).start();

// 2.1使用匿名内部类
       Runnable race1 = new Runnable() {
           @Override
           public void run() {
               System.out.println("Hello world !");
           }
       };

// 2.2使用 lambda expression
       Runnable race2 = () -> System.out.println("Hello world !");

// 直接调用 run 方法(没开新线程哦!)
       race1.run();
       race2.run();
   }
}



使用Lambdas排序集合

我们将根据球员的 name, surname, name 长度 以及最后一个字母。 和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。

String[] players = {"Rafael Nadal", "Novak Djokovic",  
   "Stanislas Wawrinka", "David Ferrer",  
   "Roger Federer", "Andy Murray",  
   "Tomas Berdych", "Juan Martin Del Potro",  
   "Richard Gasquet", "John Isner"};  
 
// 1.1 使用匿名内部类根据 name 排序 players  
Arrays.sort(players, new Comparator<String>() {  
   @Override
   public int compare(String s1, String s2) {  
       return (s1.compareTo(s2));  
   }  
});  


使用lambdas,可以通过下面的代码实现同样的功能:简洁又直观。

Stream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst() 这样的方法就会结束链式语法。 在接下来的例子中,我们将探索lambdas和streams 能做什么。 我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:

我们将创建两个list,都用来存放Person对象:

List<Person> javaProgrammers = new ArrayList<Person>() {  
 {  
   add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));  
   add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));  
   add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));  
   add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));  
   add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));  
   add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));  
   add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));  
   add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));  
   add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));  
   add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));  
 }  
};  
 
List<Person> phpProgrammers = new ArrayList<Person>() {  
 {  
   add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));  
   add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));  
   add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));  
   add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));  
   add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));  
   add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));  
   add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));  
   add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));  
   add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));  
   add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));  
 }  
};


现在我们使用forEach方法来迭代输出上述列表:

System.out.println("所有程序员的姓名:");  
javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  
phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  


我们同样使用forEach方法,增加程序员的工资5%:

另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的Java程序员:

我们也可以定义过滤器,然后重用它们来执行其他操作:

排序呢? 我们在stream中能处理吗? 答案是肯定的。 在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:

System.out.println("根据 name 排序,并显示前5个 Java programmers:");  
List<Person> sortedJavaProgrammers = javaProgrammers  
         .stream()  
         .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName())))  
         .limit(5)  
         .collect(toList());  
 
sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));  
 
System.out.println("根据 salary 排序 Java programmers:");  
sortedJavaProgrammers = javaProgrammers  
         .stream()  
         .sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) )  
         .collect( toList() );  
 
sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));


如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:

上面的例子中我们已经看到 collect 方法是如何工作的。 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:

Streams 还可以是并行的(parallel)。 示例如下:

System.out.println("计算付给 Java programmers 的所有money:");  
int totalSalary = javaProgrammers  
         .parallelStream()  
         .mapToInt(p -> p.getSalary())  
         .sum();  


我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:

//计算 count, min, max, sum, and average for numbers  
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  
IntSummaryStatistics stats = numbers  
         .stream()  
         .mapToInt((x) -> x)  
         .summaryStatistics();  
 
System.out.println("List中最大的数字 : " + stats.getMax());  
System.out.println("List中最小的数字 : " + stats.getMin());  
System.out.println("所有数字的总和   : " + stats.getSum());  
System.out.println("所有数字的平均值 : " + stats.getAverage());  


总结：

• 1、Lambda表达式是Java8的新特性，可以让我们使用少量的代码实现功能

• 2、使用 Lambda 表达式可以使代码变的更加简洁紧凑。

• 3、使用他的前提是你们公司或者你们项目组知道这个东西才行，不然别人不会以后很难维护看懂代码。

• 4、作用域:lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

• 5、语法：

  (parameters) -> expression 或 (parameters) ->{ statements; }

  特征：

• **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。

• **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。

• **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。

• **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。