Lambda表达式详解-蒲公英云

文章目录

前言
一、从匿名内部类到Lambda表达式
二、Lambda表达式的语法
- 1.语法格式1：无参无返回值（指的是函数式接口的方法）
- 2.语法格式2：有参无返回值
- 3.语法格式3：当只有一个参数时，参数的小括号可以省略
- 4.语法格式4：有参有返回值
- 5.语法格式5：当只有一条语句体，return 和大括号可以省略
- 6.语法格式6：参数类型可以省略不写，编译器会自动进行上下文的类型推断
三、函数式接口
- 1.什么是函数式接口？
- 2.自定义函数式接口
- 3.作为参数传递的Lambda表达式
- 4.Java内置的四个函数式接口
- - 消费型接口Consumer< T >
  - 供给型接口Supplier< T >
  - 函数型接口Function< T >
  - 断定型接口Predicate< T >
四、方法引用与构造引用
- 1、方法引用
- 2、构造引用
总结

前言

Lambda表达式是JDK1.8的新特性，本篇来学习Lambda表达式

一、从匿名内部类到Lambda表达式

Lambda表达式实质上是匿名内部类的一种变型

首先使用maven新建一个java项目
，导入junit单元测试依赖，需要注意的是，我们可以把< scope>标签给删除，以此来让我们的项目的每一个包都可以使用@Test注解
案例：
使用Lambda表达式new一个接口

public class LambdaDemo1 {
       @Test
       public void test(){
           //使用匿名内部类new一个接口
           Runnable r1 = new Runnable() {
               @Override
               public void run() {
                   System.out.println("hello world！！");
               }
           };
            r1.run();
           //使用Lambda表达式
           Runnable r2 = () -> System.out.println("hello world");
           r2.run();
       }
}

案例：使用匿名内部类进行参数传递

@Test
    public void test1(){
       //使用匿名内部类作为参数传递 以TreeSet集合为例
        TreeSet<String> t1 = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        //使用Lambda表达式
        TreeSet<String> t2 = new TreeSet<>(
                (o1,o2) -> Integer.compare(o1.length(),o2.length())
        );
    }

二、Lambda表达式的语法

Lambda表达式在java语言中引入了一个新的语法元素和操作符，箭头符号 ->
该符号被称作Lambda操作符或者箭头操作符，它将Lambda表达式分为两个部分
左侧：指定了Lambda表达式需要的参数对应函数式接口的方法参数
右侧：指定了Lambda表达式体，即表达式所要完成的功能对应函数式接口的方法体
Lambda表达式需要函数式接口的支持？什么是函数式接口，即这个接口只有一个抽象方法
一般来讲，函数式接口会有一个注解@FunctionalInterface来标注，注意，被该注解标注一定是
函数式接口，没有被标注，也不一定不是函数式接口
Lambda表达式就是根据函数式接口的方法来编写的。

1.语法格式1：无参无返回值（指的是函数式接口的方法）

@Test
    public void test2(){
        Runnable r2 = () -> System.out.println("hello world");
        r2.run();
    }

2.语法格式2：有参无返回值

@Test
    public void test3(){
        Consumer<String> c1 = (str) -> System.out.println(str);
        c1.accept("这是参数");
    }

3.语法格式3：当只有一个参数时，参数的小括号可以省略

@Test
    public void test4(){
        Consumer<String> c1 = str -> System.out.println(str);
        c1.accept("这是参数");
    }

4.语法格式4：有参有返回值

@Test
    public void test5(){
        BinaryOperator<Integer> b1 = (num1,num2) ->{
            System.out.println("实现了有参有返回值");
          return num1+num2;
        };
        System.out.println(b1.apply(2,3));
    }

5.语法格式5：当只有一条语句体，return 和大括号可以省略

@Test
    public void test6(){
        BinaryOperator<Integer> b1 = (num1,num2) -> num1+num2;
        System.out.println(b1.apply(2,3));
    }

6.语法格式6：参数类型可以省略不写，编译器会自动进行上下文的类型推断

三、函数式接口

1.什么是函数式接口？

函数式接口就是只有一个抽象方法的接口。被称为函数式接口
可以通过Lambda表达式来创建函数式接口的对象
可以在任意函数式接口上使用@FunctionalInterface来标注当前接口是一个函数式接口

2.自定义函数式接口

我们可以使用注解来自定义函数式接口
在这里插入图片描述

3.作为参数传递的Lambda表达式

Lambda表达式本质上是一个函数式接口的实例对象
我们可以把Lambda表达式当作一个方法的参数传递
案例：
在这里插入图片描述

4.Java内置的四个函数式接口

消费型接口Consumer< T >

消费型接口Consumer< T > 参数为T 返回值为void void accept(T t)

@Test
    public void test(){
        playGame(12.0,(money)->{
            System.out.println("电竞区体验感十足，可以办个会员,网费为："+money+"每小时");
        });
    }
    public void playGame(Double money, Consumer<Double> consumer){
        consumer.accept(money);
    }

运行结果：
在这里插入图片描述

供给型接口Supplier< T >

供给型接口Supplier< T > 无参数有返回值 T get()

@Test
    public void test1(){
       study(() -> "好好学习，天天向上" );
    }
    public void study(Supplier<String> supplier){
        String s = supplier.get();
        System.out.println(s);
    }

运行结果：
在这里插入图片描述

函数型接口Function< T >

函数型接口Function< T > 参数类型为T 返回值为R 对类型为T的参数进行加工返回值为R类型的结果 apply(T t)

@Test
    public void test2(){
        study("HELLO WORLD",(str) -> {
            return str.toLowerCase();
        });
    }
    public void study(String str, Function<String,String> function){
        String s = function.apply(str);
        System.out.println(s);
    }

执行结果：
在这里插入图片描述

断定型接口Predicate< T >

断定型接口Predicate< T > 参数类型为T 返回值为boolean 对参数T的类型进行判断看是否满足条件 boolean test(T t)

@Test
    public void test3(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,7,8,9);
        List<Integer> num1 = getNum(integers, (num) -> {
            return num % 2 == 0;
        });
        num1.stream().forEach(System.out::println);
    }
    public List<Integer> getNum(List<Integer> list, Predicate<Integer> predicate){
        ArrayList<Integer> integers = new ArrayList<>();
        for (Integer i : list) {
            if (predicate.test(i)){
                integers.add(i);
            }
        }
        return integers;
    }