Java8引入的 Lambda 表达式也称为闭包，是推动Java8发布的最重要的新特性。Lambda 是一个匿名函数，主要作用就是简化部分匿名内部类的写法。我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用 Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，它使Java的语言表达能力得到了提升。

a5fcfb1055a1bc13d3a5d171171f6379

1、Lambda新特性简介

Java8中引入了一个新的操作符，“->”，该操作符称为箭头操作符或者Lambda操作符，箭头操作符将Lambda表达式拆分成两部分；

左侧: Lambda表达式的参数列表，对应的是接口中抽象方法的参数列表；
右侧: Lambda表达式中所需要执行的功能(Lambda体)，对应的是对抽象方法的实现；
Lambda表达式的实质是对接口的实现，能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口（lambda表达式必须和接口进行绑定）；
所谓函数式接口（function interface），是指内部有且仅有一个抽象方法的接口。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
Lambda 表达式有一个类型推断机制，在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指定。

1.1 Lambda语法

lambda 表达式的语法格式如下：

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

分情况语法示范：

（1）语法格式一：无参，无返回值，Lambda 体只需一条语句
  示例：Runnable r1 = () -> System.out.println("Hello Lambda!");

（2）语法格式二：Lambda 需要一个参数 
  示例：Consumer<String> con = （x） -> System.out.println(x);

（3）语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略 
  示例：Consumer<String> con = x -> System.out.println(x);

（4）语法格式四：Lambda 需要两个参数，并且有返回值 
  示例：
 Comparator<Integer> com = (x, y) -> {
   System.out.println("函数式接口");
   return Integer.compare(x, y);
 };

（5）语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略 
  示例：Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

（6）Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
  示例：
Comparator<Integer> com = (Integer x,Integer y) -> {  //Integer 类型可以省略
   System.out.println("函数式接口");
   return Integer.compare(x, y);
 };

根据上述语法可知，组成Lambda表达式的三要素：形式参数，箭头，代码块：

① 格式：(形式参数) -> {代码块}。
② 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可。
③ ->：由英文中划线和大于符号组成，固定写法。代表指向动作。
④ 代码块：是我们具体要做的事情，也就是我们写的方法体内容。

语法看起来很简答，其实就是通过箭头表达式替代匿名内部类。以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值 parameters。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体只包含一条语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

1.2 Lambda的优点

使用 Lambda 表达式可以使代码变的更加简洁紧凑。以下简单列了一下它的优点：

速度更快
代码更少（增加了新的语法Lambda表达式）
强大的Stream API
便于并行
最大化减少空指针异常Optional
类型推断：Lambda 表达式中的参数类型都是由编译器推断得出的。

Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断”。

1.3 Lambda简单实例

为了更直观的看到Lambda的写法，我们列出几个Lambda 表达式的简单示例：

// 1. 不需要参数,返回值为 5。
// 无参数时不可省略参数的括号
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值。
// 一个参数，可省略参数外的括号
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值
// 多个参数，不可省略参数的括号
// 如果只有一个语句，也可省略return关键字
// 参数类型可省略，根据要实现的接口的方法能推导出来
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和
// 单条语句，可省略语句的大括号
// 如果只有一个语句，也可省略return关键字
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
// 单条语句，可省略语句的大括号
(String s) -> System.out.print(s)
  
// 6. 多条语句，语句需要加大括号
() -> {
        System.out.println("lambda1");
        System.out.println("lambda2");
     };

根据示例可以得出如下结论：

无参数或多个参数时不可省略参数的括号。
一个参数，可省略参数外的括号。
参数类型可省略，可以根据要实现的接口的方法推导出来。
如果只有一个语句，也可省略return关键字。
参数体为单条语句时，可省略语句的大括号。多条语句时需要参数体需要加大括号。

2、实现类、匿名类到Lambda的转换实例

以下是分别使用实现类，匿名类，Lambda实现一个多线程的例子，它们的表示方式虽然不同，但最终效果是相同的。

2.1 方式1：实现类

定义一个类MyRunnable实现Runnable接口，重写run()方法。

//创建MyRunnable类的对象
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程程序启动了...");
    }
}

public class LambdaDemo {
    public static void main(String[] args) {
        //实现类的方式实现需求
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable的对象作为构造参数传递
        Thread t = new Thread(my);
        //启动线程
        t.start();
    }
}

2.2 方式2：匿名内部类

以下是使用匿名内部类对上述实现类的方式进行了改进，可以看到代码简洁了很多。我们只需要关注接口的run方法实现。

public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类的方式改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了...");
            }
        }).start();
    }
}

2.3 方式3：Lambda表达式

本例中对匿名内部类的方式进行了改进，使用了Lambda表达式，代码结构更加清晰，关注点进一步明确，我们甚至都不需要知道接口的方法申明，只需要关注方法体的实现，即我们的业务逻辑代码。

public class LambdaDemo {
    public static void main(String[] args) {
        //Lambda表达式方式改进
        new Thread(() -> {
            System.out.println("多线程程序启动了...");
        }).start();
    }
}

Lambda表达式中的代码解析：

()：里面没有内容，可以看成是方法形式参数为空
->：用箭头指向后面要做的事情
{ }：包含一段代码，我们称之为代码块，可以看成是方法体中的内容

3、自定义接口使用Lambda的实例

Lambda表达式的使用前提：

① 有一个接口。
② 接口中有且仅有一个抽象方法。

根据上述约束，我们自定义一个仅有一个抽象方法的接口。

public interface Eatable {
    void eat();
}

3.1 方式1：实现类

class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}

public class EatableDemo {
    public static void main(String[] args) {
        // 调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);
	}
    private static void useEatable(Eatable e){
        e.eat();
    }
}

3.2 方式2：匿名内部类

public class EatableDemo {
    public static void main(String[] args) {

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });
    }

    private static void useEatable(Eatable e){
        e.eat();
    }
}

3.3 方式3：Lambda表达式

public class EatableDemo {
    public static void main(String[] args) {
        //用Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e){
        e.eat();
    }
}

4、函数式接口

只包含一个抽象方法的接口，称为函数式接口。可以通过 Lambda 表达式来创建该接口的对象。

4.1 自定义函数接口

我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

@FunctionalInterface
Public interface MyNumber{
    public double getValue();
}

// 函数式接口中使用泛型
@FunctionalInterface
Public interface MyFun<T>{
    public T getValue(T t);
}

4.2 作为参数传递的Lambda表达式

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

public String toUpperString(MyFun<String> mf, String str){
    return mf.getValue(str);
}
  
// 作为参数传递Lambda表达式：
String newStr = toUpperString(
(str) - > str.toUpperCase(), “abcdef”);
System.out.println(newStr);

4.3 Java 内置四大核心函数式接口

Java8中的java.util.function包中提供了一些常用的函数式功能接口。

4.3.1 消费型接口 `Consumer<T>`

对类型为T的对象应用操作，包含方法 void accept(T t)，参数类型为T，返回类型为void，示例如下：

// Consumer<T> 消费型接口 :
@Test
public void test1(){
  happy(10000, (m) -> System.out.println("每次消费：" + m + "元"));
}

public void happy(double money, Consumer<Double> con){
  con.accept(money);
}

4.3.2 供给型接口 `Supplier<T>`

返回类型为T的对象，包含方法 T get()，无参数，返回类型为T，示例如下：

//Supplier<T> 供给型接口 :
@Test
public void test2(){
  List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
  for (Integer num : numList) {
   System.out.println(num);
  }
}

//需求：产生指定个数的整数，并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
  List<Integer> list = new ArrayList<>();
  for (int i = 0; i < num; i++) {
   Integer n = sup.get();
   list.add(n);
  }   
  return list;
}

4.3.3 函数型接口 `Function<T, R>`

对类型为T的对象应用操作并返回结果。结果是R类型的对象。包含方法 R apply(T t)，参数类型为T，返回类型为R，示例如下：

//Function<T, R> 函数型接口：
@Test
public void test3(){
  String newStr = strHandler("\t\t\t 我大尚硅谷威武 ", (str) -> str.trim());
  System.out.println(newStr);
  String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
  System.out.println(subStr);
}

//需求：用于处理字符串
public String strHandler(String str, Function<String, String> fun){
  return fun.apply(str);
}

4.3.4 断言型接口 `Predicate<T>`

确定类型为T的对象是否满足某约束，并返回boolean值。包含方法 boolean test(T t)，参数类型为T，返回类型为布尔值，示例如下：

//Predicate<T> 断言型接口：
@Test
public void test4(){
  List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
  List<String> strList = filterStr(list, (s) -> s.length() > 3);
  for (String str : strList) {
   System.out.println(str);
  }
}

//需求：将满足条件的字符串，放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
  List<String> strList = new ArrayList<>();
  for (String str : list) {
   if(pre.test(str)){
    strList.add(str);
   }
  }
  return strList;
}

4.3.5 其他接口

5、Lambda表达式和匿名内部类的区别

5.1 所需类型不同

① 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
② Lambda表达式：只能是接口

abstract class Animal {
    public abstract void method();
}
class Student {
    public void study(){
        System.out.println("爱生活,爱java");
    }
}

public class LambdaDemo{
    public static void main(String[] args) {
        /*//匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });

        useStudent(new Student(){
            @Override
            public void study(){
                System.out.println("具体类");
            }
        });*/

        //Lambda
        useInter(() -> System.out.println("接口"));
        //useAnimal(() -> System.out.println("抽象类"));//不可以
        //useStudent(() -> System.out.println("具体类"));//不可以
    }
    private static void useStudent(Student s){
        s.study();
    }
    private static void useAnimal(Animal a){
        a.method();
    }
    private static void useInter(Inter i){
        i.show();
    }
}

5.2 使用限制不同

① 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
② 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

public interface Inter{
    void show();
    void show1();
}

public class LambdaDemo{
    public static void main(String[] args) {
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("show"); // 只打印这一个show
            }
            @Override
            public void show1() {
                System.out.println("show");
            }
        });
    }

    private static void useInter(Inter i){
        i.show();
    }
}

5.3 实现原理不同

① 匿名内部类：编译之后，产生一个单独的.class字节码文件
② Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

6、方法引用和构造器引用

6.1 方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）

方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。

方法引用格式： ClassName::MethodName

注意：

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

如下三种主要使用情况：

（1）对象::实例方法

@Test
public void test1(){
  PrintStream ps = System.out;
  Consumer<String> con = (str) -> ps.println(str);
  con.accept("Hello World！");
 
  System.out.println("--------------------------------");
 
  Consumer<String> con2 = ps::println;
  con2.accept("Hello Java8！");
 
  Consumer<String> con3 = System.out::println;
}
 
@Test
public void test2(){
  Employee emp = new Employee(101, "张三", 18, 9999.99);
 
  Supplier<String> sup = () -> emp.getName();
  System.out.println(sup.get());
 
  System.out.println("----------------------------------");
 
  Supplier<String> sup2 = emp::getName;
  System.out.println(sup2.get());
}

（2）类::静态方法

@Test
public void test3(){
  BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
  System.out.println(fun.apply(1.5, 22.2));
 
  System.out.println("--------------------------------------------------");
  BiFunction<Double, Double, Double> fun2 = Math::max;
  System.out.println(fun2.apply(1.2, 1.5));
}

@Test
public void test4(){
  Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 
  System.out.println("-------------------------------------");  
  Comparator<Integer> com2 = Integer::compare;
}

（3）类::实例方法

@Test
public void test5(){
  BiPredicate<String, String> bp = (x, y) -> x.equals(y);
  System.out.println(bp.test("abcde", "abcde"));
 
  System.out.println("-----------------------------------------");
  BiPredicate<String, String> bp2 = String::equals;
  System.out.println(bp2.test("abc", "abc"));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun = (e) -> e.show();
  System.out.println(fun.apply(new Employee()));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun2 = Employee::show;
  System.out.println(fun2.apply(new Employee()));   
}

6.2 构造器引用

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

构造器引用格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。

可以把构造器引用赋值给定义的方法，与构造器参数

列表要与接口中抽象方法的参数列表一致！

和方法引用一样，构造器本质上也是一个 <init> 方法

Function<Integer, MyClass> fun = (n) -> new MyClass(n);

等同于：

Function<Integer, MyClass> fun = MyClass::new;

示例：

@Test
public void test1() {
　　Function<Integer, Person> f1 = new Function<Integer, Person>() {
　　　　@Override
　　　　public Person apply(Integer t) {
　　　　　　return new Person(t);
　　　　}
　　};
　　// ----------------------------lambda表达式------------------------------
　　Function<Integer, Person> f2 = t -> new Person(t);
　　// -----------------------------构造器的引用-----------------------------
　　Function<Integer, Person> f3 = Person::new;
}

示例解释：

Apply()方法中第一个泛型是形参类型，第二个泛型是返回值返回值类型，所以构造器引用时，将返回类型的对象new，将第一个参数作为形参

6.3 数组引用

构造器引用的特例

数组引用格式：type[]::new

Function<Integer, Integer[]> fun = (n) -> new Integer[n];

等同于：

Function<Integer, Integer[]> fun = Integer[]::new;

示例：

/**
 * 数组引用
 */
@Test
public void test2() {
　　Function<Integer, Person[]> f1 = new Function<Integer, Person[]>() {
　　　　@Override
　　　　public Person[] apply(Integer t) {
　　　　　　return new Person[t];
　　　　}
　　};
　　// ---------------------------------lambda表达式------------------------------
　　Function<Integer, Person[]> f2 = t -> new Person[t];
　　// ---------------------------------数组的引用------------------------------
　　Function<Integer, Person[]> f3 = Person[]::new;
　　// 调用
　　Person[] apply = f3.apply(10);
}

示例解释：

Apply()方法中第一个泛型是形参类型，第二个泛型是返回值返回值的数组类型，所以构造器引用时，将返回类型的对象new，将第一个参数作为返回数组的长度

使用案例：

List<String> newStrList = Arrays.asList(1,2,3,4,5).stream().map(String::new).collect(Collectors.toList());

7、Lambda表达式应用实战

7.1 示例1

// 1、匿名内部类
Comparator<Integer>com = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {  //降序排列
        return Integer.compare(o2,o1);
        // return o2 - o1;
    }
};

// 2、Lambda 表达式
Comparator<Integer> com = (x, y) -> Integer.compare(y, x);

7.2 数组排序

List<Integer> list = Arrays.asList(33,44,55,33,22);

// 1、匿名内部类的方式
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
 
        return o1 - o2;
 
    }
 
});
 
// 2、lambda 表达式的方式
Collections.sort(list, (p1, p2) -> p1 - p2); 

// 3、静态方法的引用
Collections.sort(list, LambdbTest::compar);
 
public static int compar(Integer p1, Integer p2) {
    return p1-p2;
 
}

7.3 获取stream对象

// 1、批量数据，stream对象
 
Stream stream = Stream.of("admin", "ossuser");
 
// 2、数组
 
int[] array = new int[]{1,3,4};
 
IntStream stream1 = Arrays.stream(array);
 
// 2、集合
 
List<String> list = Arrays.asList("admin", "ossuser");
 
Stream<String> stream2 = list.stream();
 
// 3、Map
 
Map<String, String> map = new HashMap<>();
 
map.put("name", "admin");
 
Stream<Map.Entry<String, String>> stream3 = map.entrySet().stream();
 
// 3、stream对基类型类型的功能封装
 
IntStream intStream = IntStream.of(3);
 
IntStream.range(1, 5).forEach(System.out::println); // 左闭右开
 
IntStream.rangeClosed(1, 5).forEach(System.out::println); // 左闭又闭

7.4 Stream对象转为指定数据

// 1、数组
Object[] ints = stream.toArray(String[]::new);

// 2、字符串
String collect1 = stream.collect(Collectors.joining()).toString();
 
// 3、集合
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
 
// 4、map
Map<String, String> map1 = (Map<String, String>) stream.collect(Collectors.toMap(x -> x, y -> "value" + y));

7.5 其他API操作

List<String> list2 = Arrays.asList("admin", "user", "ossuser");
 
// 1、map() 中间操作，map()方法接收一个Function接口
List<String> strings = list2.stream().map(x -> x + "test").collect(Collectors.toList());
 
// 2、filter() 添加过滤条件，过滤满足条件的用户
List<String> collect = list2.stream().filter(x -> x.length() > 2).collect(Collectors.toList());
 
// 3、forEach 增强型循环
list2.forEach(System.out::print);
 
// 4、peek() 中间操作，迭代数据依次处理过程，实现数据的多次迭代
list2.stream()
        .peek(x -> System.out.println(x + "1"))
        .peek(x -> System.out.println(x + "2"))
        .forEach(System.out::println);
 
// 5、skip()  中间操作，有状态，跳过部分数据
list2.stream().skip(1).forEach(System.out::println);
 
// 6、limit() 中间操作，有状态，限制输出数据量
list2.stream().limit(2).forEach(System.out::println);
 
// 7、distinct() 中间操作，有状态，去重
list2.stream().distinct().forEach(System.out::println);

目录CONTENT

java8新特性Lambda表达式使用方法详解

1、Lambda新特性简介

1.1 Lambda语法

1.2 Lambda的优点

1.3 Lambda简单实例

2、实现类、匿名类到Lambda的转换实例

2.1 方式1：实现类

2.2 方式2：匿名内部类

2.3 方式3：Lambda表达式

3、自定义接口使用Lambda的实例

3.1 方式1：实现类

3.2 方式2：匿名内部类

3.3 方式3：Lambda表达式

4、函数式接口

4.1 自定义函数接口

4.2 作为参数传递的Lambda表达式

4.3 Java 内置四大核心函数式接口

4.3.1 消费型接口 `Consumer<T>`

4.3.2 供给型接口 `Supplier<T>`

4.3.3 函数型接口 `Function<T, R>`

4.3.4 断言型接口 `Predicate<T>`

4.3.5 其他接口

5、Lambda表达式和匿名内部类的区别

5.1 所需类型不同

5.2 使用限制不同

5.3 实现原理不同

6、方法引用和构造器引用

6.1 方法引用

6.2 构造器引用

6.3 数组引用

7、Lambda表达式应用实战

7.1 示例1

7.2 数组排序

7.3 获取stream对象

7.4 Stream对象转为指定数据

7.5 其他API操作

评论区

java8新特性Lambda表达式使用方法详解

1、Lambda新特性简介

1.1 Lambda语法

1.2 Lambda的优点

1.3 Lambda简单实例

2、实现类、匿名类到Lambda的转换实例

2.1 方式1：实现类

2.2 方式2：匿名内部类

2.3 方式3：Lambda表达式

3、自定义接口使用Lambda的实例

3.1 方式1：实现类

3.2 方式2：匿名内部类

3.3 方式3：Lambda表达式

4、函数式接口

4.1 自定义函数接口

4.2 作为参数传递的Lambda表达式

4.3 Java 内置四大核心函数式接口

4.3.1 消费型接口 Consumer<T>

4.3.2 供给型接口 Supplier<T>

4.3.3 函数型接口 Function<T, R>

4.3.4 断言型接口 Predicate<T>

4.3.5 其他接口

5、Lambda表达式和匿名内部类的区别

5.1 所需类型不同

5.2 使用限制不同

5.3 实现原理不同

6、方法引用和构造器引用

6.1 方法引用

6.2 构造器引用

6.3 数组引用

7、Lambda表达式应用实战

7.1 示例1

7.2 数组排序

7.3 获取stream对象

7.4 Stream对象转为指定数据

7.5 其他API操作

评论区

4.3.1 消费型接口 `Consumer<T>`

4.3.2 供给型接口 `Supplier<T>`

4.3.3 函数型接口 `Function<T, R>`

4.3.4 断言型接口 `Predicate<T>`