Lambda表达式与函数式接口

Lambda表达式与函数式接口

1. 函数式接口

1.1 什么是函数式接口

        函数式接口是指只有一个抽象方法的接口（Object的public方法除外。）。这种接口可以使用Lambda表达式实现，从而实现函数式编程的特性。另外函数式接口可以有默认方法和静态方法。
         建议：在定义函数式接口时，建议标记@FunctionalInterface注解，虽然不标记也不会影响接口的功能，但加上这个注解可以帮助编辑器检测是否错误地添加了多个抽象方法。
示例：

@FunctionalInterface
public interface Func{
    Object clone();   // Object的方法
    void run();       // 自定义抽象方法
}

​1.2  4个基本的函数式接口

        消费型接口：Consumer void accept(T t)：
        消费型接口表示接收一个参数并执行某些操作，但没有返回值。它常用于需要执行一些操作但不需要返回结果的场景，例如遍历合、修改对象状态等，例如

Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("hello world");

        供给型接口：Supplier T get()：
供给型接口表示不需要接收任何参数，但需要返回一个结果。它常用于需要生成某些数据的场景，例如生成随机数、获取当前时间等，例如

Supplier<Integer> supplier = () -> (int) (Math.random() * 100);
System.out.println(supplier.get());

        函数型接口：Function<T,R> R apply(T t)：
函数型接口表示接收一个参数并返回一个结果。它常用于需要对某些数据进行处理并返回结果的场景，例如字符串转换、数据加工等。例如：

Function<String, Integer> function = s -> s.length();
System.out.println(function.apply("hello world"));

        判断型接口：Predicate boolean test(T t)：
判断型接口表示接收一个参数并返回一个布尔值。它常用于需要对某些数据进行判断并返回布尔值的场景，例如过滤集合、判断对象状态等，例如

Predicate<Integer> predicate = i -> i > 0;
System.out.println(predicate.test(-1));

1.3 函数式接口具有一些重要的特点和应用场景：

1. 特点：函数式接口只能有一个抽象方法，但可以有多个默认方法或静态方法。这使得函数式接口非常简洁和灵活，能够用于实现各种功能。
2. 应用场景：

• 简化代码：通过将一段代码抽象为一个函数式接口，可以在多个地方重复使用它，从而简化代码结构。
• 并行流处理：在Java 8中，可以使用函数式接口来处理并行流，实现数据的转换和过滤等操作。
• 组合逻辑：函数式接口可以用于定义复杂的逻辑操作，如两个元素的组合逻辑。
• 事件处理：在GUI编程中，函数式接口可以用于处理各种事件，如按钮点击、鼠标移动等。
• 测试：在单元测试中，函数式接口可以用于定义测试断言，提高测试的准确性和效率。

2. lambda表达式

2.1 什么是lambda?

        Lambda是JDK8的语法糖。它可以对某些匿名内部类的写法进行简化，它是函数式编程的一个重要体现。让我们不用关注什么是对象，只需要关注两部分内容即可： 参数列表 和 方法体，只关注我们对数据做了什么操作，可以说它Lambda表达式就是一个对象。总之，lambda表达式是实现函数式接口的一个快捷方式。
        注意：必须是函数式接口才可以使用lambda表达式

(参数)-> {
	⽅法体
};

public class LambdaTest {

    @Test
    public void test1(){
// Runnable只有一个抽象方法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("知昂可");
            }
        };
        r1.run();

        System.out.println("***********************");

  //Lambda表达式
        Runnable r2 = () -> {
                System.out.println("知昂可");
        };

        r2.run();

    }
    @Test
    public void test2(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        int compare1 = com1.compare(12,21);
        System.out.println(compare1);

        System.out.println("***********************");
        
        //Lambda表达式的写法,箭头后的{}是可以省略的，参数类型确定也可以省略
        
        Comparator<Integer> com2 =  (Integer o1, Integer o2) -> Integer.compare(o1,o2);
        //  Comparator<Integer> com2 =  (o1, o2) -> Integer.compare(o1,o2);
        int compare2 = com2.compare(23,21);
        System.out.println(compare2);

        System.out.println("***********************");
        //方法引用
        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(23,21);
        System.out.println(compare3);
    }
}

public class LambdaTest1 {
    //语法格式一：无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("知昂可");
            }
        };

        r1.run();

        System.out.println("***********************");
        Runnable r2 = () -> {
            System.out.println("知昂可");
        };

        r2.run();


    }
    //语法格式二：Lambda 需要一个参数，但是没有返回值。
    @Test
    public void test2(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("知昂可在学习");

        System.out.println("*******************");

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };

        con1.accept("知昂可在摸鱼");

    }

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test3(){

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("知昂可休息中...");

        System.out.println("*******************");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con1.accept("知昂可休息中...");

    }


    @Test
    public void test3_1(){
        int[] arr = {1,2,3,4}; //类型推断

        HashMap<String,Integer> map = new HashMap<>();//类型推断

        var entrySet = map.entrySet(); //类型推断 ,在jdk10及之后可以用,现持续存在

    }


    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("知昂可休息中...");

        System.out.println("*******************");

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("知昂可正在睡觉...");


    }

    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        System.out.println(com1.compare(12,21));

        System.out.println("*****************************");

        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        System.out.println(com2.compare(12,21));
    }

    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test6(){

        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };

        System.out.println(com1.compare(12,6));

        System.out.println("*****************************");

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

        System.out.println(com2.compare(12,16));
    }

    @Test
    public void test7(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("知昂可正在玩耍...");

        System.out.println("*****************************");
    }
}

总结：

Lambda表达式的使用举例：
        (o1, o2) -> Integer.compare(o1,o2);

Lambda表达式的格式举例:
        lambda形参列表 -> lambda体

Lambda表达式的格式：
        lambda操作符或箭头操作符
        -> 的左边: lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
        -> 的右边: lambda体，对应着接口的实现类要重写的方法的方法体。
Lambda表达式的本质：
        一方面，lambda表达式作为接口的实现类的对象。 --->说白了Lambda表达式就是对象， "万事万物皆对象" 。       另一方面，lambda表达式是一个匿名函数。