为什么引入Lambda表达式？

lambda概念来自于数学。λ演算，λ(Lambda（大写Λ，小写λ）读音：lan b（m） da（兰亩达）[‘læ;mdə])演算是一套用于研究函数定义、函数应用和递归的形式系统。其本质就是一个函数。

由数学界发展而来，成为编程届的一种思想，叫做函数式编程思想。每一个功能用一个函数去实现，函数优先，区别于面向对象思想。好处是可以简化代码，不需要先创建一个对象，再给对象创建方法。直接创建方法即可使用，尤其是在UI操作，是件回调等操作时，十分便利。

由于大部分语言都已经支持函数式编程，只有Java还紧抱面向对象，所以Java8开始支持函数式编程。

表现在代码中就是我们平时说的: 闭包 /匿名方法 /匿名函数，可以将一段代码直接作为参数传递，简化代码。

在Java中，Lambda的本质就是一个interface的匿名内部类的实现。Java8只是优化了语法糖。

快速上手

来个例子：

  1. (x,y)->{return x+y;}
  • 基本格式： （参数列表）->{方法体}
  • ->符号代表了lambda表达式，读作λ（lambda 读音：兰木达）
  • 示例：（x,y）->{System.out.println(x+y);}
  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
  • 以上lambda表达式还可以简化，jdk8还提供一种更简单的语法糖——方法引用。
  • 用双冒号:: 表示方法引用。例如：Person::getName 等同于new Person().getName()

    简单几个例子

    无参数，无返回值 ()->{}
  1. Runnable runnable = ()-> System.out.println("runnable方法执行");
  2. runnable.run();
  3. //等同于
  4. Runnable run = new Runnable() {
  5.     @Override
  6.     public void run() {
  7.         System.out.println("runnable方法执行");
  8.     }
  9. };
  10. run.run();

有一个参数，无返回值

  2. Consumer<String> consumer1 =(x)-> {System.out.println(x);}; 
  3. Consumer<String> consumer2 =(x)-> System.out.println(x);//只有一条语句 右大括号可以不写
  4. Consumer<String> consumer3 =x-> System.out.println(x);// 只有一个参数 左大括号可以不写
  5. Consumer<String> consumer4 = System.out::println;//可以简写为方法引用
  6. consumer4.accept("执行");
  7. //等同于
  8. Consumer<String> consumer5 = new Consumer<String>() {
  9.     @Override
  10.     public void accept(String s) {
  11.         System.out.println(s);
  12.     }
  13. };
  14. consumer5.accept("执行");

有两个参数以上，方法体有多条语句

  1. Comparator<Integer> comparator = (x,y)->{
  2.     System.out.println(x);
  3.     System.out.println(y);
  4.     return Integer.compare(x,y);
  5. };
  6. int compare = comparator.compare(1, 3);
  7. System.out.println(compare);
  8. //等同于以下写法
  9. Comparator<Integer> comparator1 = new Comparator<Integer>() {
  10.     @Override
  11.     public int compare(Integer x, Integer y) {
  12.         System.out.println(x);
  13.         System.out.println(y);
  14.         return Integer.compare(x,y);
  15.     }
  16. };
  17. int compare1 = comparator1.compare(1, 3);
  18. System.out.println(compare);

需要注意的地方

  1. //jdk自动识别类型 自动识别x为Integer
  2. Consumer<Integer> consumer = x-> System.out.println(x);
  3. //相类似的还有集合
  4. Set<Integer> set = new HashSet<>();//此处<>自动识别为Integer类型
  6. //lambda传参默认是final的，因为jdk7中interface只能接受常量，这里需要兼容以前的jdk
  7. int x =1;
  8. //final  int x= 1;//等同于
  9. Function f = ()-> {
  10.     //x= 2;// 报错：Variable used in lambda expression should be final or effectively final
  11.     System.out.println(x);
  12. };

例子：比较两个数字大小

  1. package com.demo.lambda表达式;
  3. import org.junit.Test;
  5. import java.util.Comparator;
  6. import java.util.TreeSet;
  8. /**
  9.  * lambda表达式示例
  10.  */
  11. public class LambdaDemo {
  13.     @Test
  14.     public void jdk7() {
  15.         //自定义一个数字比较器  实现Comparator接口
  16.         Comparator<Integer> comparator = new Comparator<Integer>() {
  17.             @Override
  18.             public int compare(Integer o1, Integer o2) {
  19.                 return Integer.compare(o1, o2);
  20.             }
  21.         };
  23.         //自定义的比较器排序
  24.         TreeSet<Integer> treeSet = new TreeSet<>(comparator);
  25.     }
  27.     @Test
  28.     public void jdk8() {
  29.         //自定义一个数字比较器  实现Comparator接口
  30.         Comparator<Integer> comparator = (o1, o2) -> Integer.compare(o1, o2);
  31.         //自定义的比较器排序
  32.         TreeSet<Integer> treeSet = new TreeSet<>(comparator);
  33.     }
  35.     @Test
  36.     public void jdk8简化写法() {
  37.         //自定义一个数字比较器  实现Comparator接口
  38.         Comparator<Integer> comparator = Integer::compare;
  39.         //自定义的比较器排序
  40.         TreeSet<Integer> treeSet = new TreeSet<>(comparator);
  41.     }
  43.     @Test
  44.     public void jdk8继续简化() {
  45.         TreeSet<Integer> treeSet = new TreeSet<>(Integer::compare);
  46.     }
  47.     //这几种写法都相同，Lamdba表达式，仅仅是JDK给我们提供的一种语法糖，简化代码的写法
  48. }

自己实现一个Lambda表达式

  1. @FunctionalInterface
  2. public interface Fun {
  3.     void fun();
  4. }
  6. //测试接口使用
  7. public class FunTest {
  8.     public static void main(String[] args) {
  9.         Fun fun = ()->{
  10.             System.out.println("自定义fun");
  11.             System.out.println("自定义fun");
  12.         };
  13.         fun.fun();
  15.         //等同于
  16.         Fun fun1 = new Fun() {
  17.             @Override
  18.             public void fun() {
  19.                 System.out.println("自定义fun");
  20.                 System.out.println("自定义fun");
  21.             }
  22.         };
  23.         fun.fun();
  24.     }
  25. }
  • @FunctionalInterface修饰的表示这个interface为lambda接口,注解标注的只能有一个抽象方法，目的是实现Lambda表达式的同时兼容以前的jdk版本
  • 另外接口还可以支持静态方法和默认方法,如下
  1. @FunctionalInterface
  2. public interface Fun {
  4.     void fun();
  6.     //@FunctionalInterface 注解标注的只能有一个抽象方法，目的是实现Lambda表达式的同时兼容以前的jdk版本
  7.     //Multiple non-overriding abstract methods found in interface com.demo.lambda表达式.Function
  8. //    void function1();
  10.     //静态方法
  11.     static Integer add(Integer x,Integer y){
  12.         return x+y;
  13.     }
  15.     //默认方法
  16.     default Integer def(Integer x,Integer y){
  17.         return x+y;
  18.     }
  20. }
  22. //方法调用
  23. Integer def = fun.def(1, 3);
  24. Integer add = Fun.add(1, 2);

集合框架常用的Lamdba方法

  1. //集合排序
  2. List<Integer> list = Arrays.asList(1,2,4,6,7,3,4,2);
  3. list.sort(Integer::compareTo);
  4. list.forEach(System.out::print);

jdk提供的常用函数式接口

  1. package com.initit.java8.lambda表达式;
  3. import org.junit.Test;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.List;
  8. import java.util.function.Consumer;
  9. import java.util.function.Function;
  10. import java.util.function.Predicate;
  11. import java.util.function.Supplier;
  13. /*
  14.  * Java8 内置的四大核心函数式接口
  15.  *
  16.  * Consumer<T> : 消费型接口
  17.  *         void accept(T t);
  18.  *
  19.  * Supplier<T> : 供给型接口
  20.  *         T get();
  21.  *
  22.  * Function<T, R> : 函数型接口
  23.  *         R apply(T t);
  24.  *
  25.  * Predicate<T> : 断言型接口
  26.  *         boolean test(T t);
  27.  *
  28.  */
  29. public class jdk内置的函数式接口 {
  31.     //Consumer<T> 消费型接口 :
  32.     @Test
  33.     public void test1() {
  34.         happy(10000, (m) -> System.out.println("每次消费：" + m + "元"));
  35.     }
  37.     public void happy(double money, Consumer<Double> con) {
  38.         con.accept(money);
  39.     }
  42.     //Supplier<T> 供给型接口 :
  43.     @Test
  44.     public void test2() {
  45.         List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
  46.         for (Integer num : numList) {
  47.             System.out.println(num);
  48.         }
  49.     }
  51.     //需求：产生指定个数的整数，并放入集合中
  52.     public List<Integer> getNumList(int num, Supplier<Integer> sup) {
  53.         List<Integer> list = new ArrayList<>();
  54.         for (int i = 0; i < num; i++) {
  55.             Integer n = sup.get();
  56.             list.add(n);
  57.         }
  58.         return list;
  59.     }
  62.     //Function<T, R> 函数型接口：
  63.     @Test
  64.     public void test3() {
  65.         String newStr = strHandler("\t\t\t    函数型接口   ", String::trim);
  66.         System.out.println(newStr);
  68.         String subStr = strHandler("函数型接口", (str) -> str.substring(2, 5));
  69.         System.out.println(subStr);
  70.     }
  72.     //需求：用于处理字符串
  73.     public String strHandler(String str, Function<String, String> fun) {
  74.         return fun.apply(str);
  75.     }
  78.     //Predicate<T> 断言型接口：
  79.     @Test
  80.     public void test4() {
  81.         List<String> list = Arrays.asList("Hello", "aa", "Lambda", "www", "ok");
  82.         List<String> strList = filterStr(list, (s) -> s.length() > 3);
  84.         for (String str : strList) {
  85.             System.out.println(str);
  86.         }
  87.     }
  89.     //需求：将满足条件的字符串，放入集合中
  90.     public List<String> filterStr(List<String> list, Predicate<String> pre) {
  91.         List<String> strList = new ArrayList<>();
  92.         for (String str : list) {
  93.             if (pre.test(str)) {
  94.                 strList.add(str);
  95.             }
  96.         }
  97.         return strList;
  98.     }
  101. }

常见的其他接口可以参考官方文档： https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

参数引用

方法引用

若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用（可以将方法引用理解为 Lambda 表达式的另外一种表现形式）

  • 对象的引用 :: 实例方法名
  • 类名 :: 静态方法名
  • 类名 :: 实例方法名

__注意：

  1. 方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致
  2. 若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

    构造器引用

    构造器的参数列表，需要与函数式接口中参数列表保持一致

  • 类名 :: new

    数组引用

  • 类型[] :: new

  1. package com.initit.java8.lambda表达式;
  3. import org.junit.Test;
  5. import java.io.PrintStream;
  6. import java.util.Comparator;
  7. import java.util.function.*;
  9. /*
  10.  * 一、方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用
  11.  *               （可以将方法引用理解为 Lambda 表达式的另外一种表现形式）
  12.  *
  13.  * 1. 对象的引用 :: 实例方法名
  14.  *
  15.  * 2. 类名 :: 静态方法名
  16.  *
  17.  * 3. 类名 :: 实例方法名
  18.  *
  19.  * 注意：
  20.  *      ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
  21.  *      ②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName
  22.  *
  23.  * 二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！
  24.  *
  25.  * 1. 类名 :: new
  26.  *
  27.  * 三、数组引用
  28.  *
  29.  *     类型[] :: new;
  30.  *
  31.  *
  32.  */
  33. public class 方法引用 {
  34.     //数组引用
  35.     @Test
  36.     public void test8() {
  37.         Function<Integer, String[]> fun = (args) -> new String[args];
  38.         String[] strs = fun.apply(10);
  39.         System.out.println(strs.length);
  41.         System.out.println("--------------------------");
  43.         Function<Integer, Employee[]> fun2 = Employee[]::new;
  44.         Employee[] emps = fun2.apply(20);
  45.         System.out.println(emps.length);
  46.     }
  48.     //构造器引用
  49.     @Test
  50.     public void test7() {
  51.         Function<String, Employee> fun = Employee::new;
  53.         BiFunction<String, Integer, Employee> fun2 = Employee::new;
  54.     }
  56.     @Test
  57.     public void test6() {
  58.         Supplier<Employee> sup = () -> new Employee();
  59.         System.out.println(sup.get());
  61.         System.out.println("------------------------------------");
  63.         Supplier<Employee> sup2 = Employee::new;
  64.         System.out.println(sup2.get());
  65.     }
  67.     //类名 :: 实例方法名
  68.     @Test
  69.     public void test5() {
  70.         BiPredicate<String, String> bp = (x, y) -> x.equals(y);
  71.         System.out.println(bp.test("abcde", "abcde"));
  73.         System.out.println("-----------------------------------------");
  75.         BiPredicate<String, String> bp2 = String::equals;
  76.         System.out.println(bp2.test("abc", "abc"));
  78.         System.out.println("-----------------------------------------");
  81.         Function<Employee, String> fun = (e) -> e.show();
  82.         System.out.println(fun.apply(new Employee()));
  84.         System.out.println("-----------------------------------------");
  86.         Function<Employee, String> fun2 = Employee::show;
  87.         System.out.println(fun2.apply(new Employee()));
  89.     }
  91.     //类名 :: 静态方法名
  92.     @Test
  93.     public void test4() {
  94.         Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
  96.         System.out.println("-------------------------------------");
  98.         Comparator<Integer> com2 = Integer::compare;
  99.     }
  101.     @Test
  102.     public void test3() {
  103.         BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
  104.         System.out.println(fun.apply(1.5, 22.2));
  106.         System.out.println("--------------------------------------------------");
  108.         BiFunction<Double, Double, Double> fun2 = Math::max;
  109.         System.out.println(fun2.apply(1.2, 1.5));
  110.     }
  112.     //对象的引用 :: 实例方法名
  113.     @Test
  114.     public void test2() {
  115.         Employee emp = new Employee(101, "张三", 18, 9999.99);
  117.         Supplier<String> sup = () -> emp.getName();
  118.         System.out.println(sup.get());
  120.         System.out.println("----------------------------------");
  122.         Supplier<String> sup2 = emp::getName;
  123.         System.out.println(sup2.get());
  124.     }
  126.     @Test
  127.     public void test1() {
  128.         PrintStream ps = System.out;
  129.         Consumer<String> con = (str) -> ps.println(str);
  130.         con.accept("Hello World！");
  132.         System.out.println("--------------------------------");
  134.         Consumer<String> con2 = ps::println;
  135.         con2.accept("Hello Java8！");
  137.         Consumer<String> con3 = System.out::println;
  138.     }
  140.     class Employee {
  142.         private int id;
  143.         private String name;
  144.         private int age;
  145.         private double salary;
  147.         public Employee() {
  148.         }
  150.         public Employee(String name) {
  151.             this.name = name;
  152.         }
  154.         public Employee(String name, int age) {
  155.             this.name = name;
  156.             this.age = age;
  157.         }
  159.         public Employee(int id, String name, int age, double salary) {
  160.             this.id = id;
  161.             this.name = name;
  162.             this.age = age;
  163.             this.salary = salary;
  164.         }
  166.         public int getId() {
  167.             return id;
  168.         }
  170.         public void setId(int id) {
  171.             this.id = id;
  172.         }
  174.         public String getName() {
  175.             return name;
  176.         }
  178.         public void setName(String name) {
  179.             this.name = name;
  180.         }
  182.         public int getAge() {
  183.             return age;
  184.         }
  186.         public void setAge(int age) {
  187.             this.age = age;
  188.         }
  190.         public double getSalary() {
  191.             return salary;
  192.         }
  194.         public void setSalary(double salary) {
  195.             this.salary = salary;
  196.         }
  198.         public String show() {
  199.             return "测试方法引用！";
  200.         }
  202.         @Override
  203.         public int hashCode() {
  204.             final int prime = 31;
  205.             int result = 1;
  206.             result = prime * result + age;
  207.             result = prime * result + id;
  208.             result = prime * result + ((name == null) ? 0 : name.hashCode());
  209.             long temp;
  210.             temp = Double.doubleToLongBits(salary);
  211.             result = prime * result + (int) (temp ^ (temp >>> 32));
  212.             return result;
  213.         }
  215.         @Override
  216.         public boolean equals(Object obj) {
  217.             if (this == obj)
  218.                 return true;
  219.             if (obj == null)
  220.                 return false;
  221.             if (getClass() != obj.getClass())
  222.                 return false;
  223.             Employee other = (Employee) obj;
  224.             if (age != other.age)
  225.                 return false;
  226.             if (id != other.id)
  227.                 return false;
  228.             if (name == null) {
  229.                 if (other.name != null)
  230.                     return false;
  231.             } else if (!name.equals(other.name))
  232.                 return false;
  233.             if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
  234.                 return false;
  235.             return true;
  236.         }
  238.         @Override
  239.         public String toString() {
  240.             return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
  241.         }
  243.     }
  245. }