Java - Lambda表达式、函数式接口

原创已于 2022-04-04 21:52:31 修改 · 431 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #其他

于 2022-03-25 13:16:49 首次发布

JAVA # j 专栏收录该内容

28 篇文章

订阅专栏

本文介绍Java 8中引入的Lambda表达式及其简化规则，对比匿名内部类，并讲解函数式接口的概念及常见函数式接口如Supplier、Consumer、Function和Predicate的使用方法。

文章目录

第一章 Lambda表达式
第二章函数式接口
第三章参考资料

第一章 Lambda表达式

1. Lambda表达式概述

JDK 8 新特性
作用：简化函数式接口的匿名内部类的写法

标准格式：

(参数类型 参数名称) -> { 方法体 }

2. 接口实现类、匿名内部类、Lambda表达式对比

package com.note.functions_interface_test;
public class Test {
    public static void main(String[] args) {
        //如何使用接口中的方法？

        //方式一 普通形式
        //1.创建接口的实现类MyInterfaceImpl,实现接口MyInterface,覆盖重写抽象方法
        //2.创建实现类对象,调用方法
        new MyInterfaceImpl().method(10);

        //方式二 匿名内部类
        //不需要自己创建实现类了,从out中的.class文件可以看出，jvm会帮我们创建接口实现类，
        new MyInterface(){
            @Override
            public void method(int a) {
                System.out.println(a);
            }
        }.method(10);

        //方式三 Lambda简化匿名内部类
        ((MyInterface)(int a)-> System.out.println(a)).method(10);
    }
}
//接口
@FunctionalInterface
interface MyInterface {
    void method(int a);
}
//接口的实现类
class MyInterfaceImpl implements MyInterface{
    @Override
    public void method(int a){
        System.out.println(a);
    }
}

package com.alibaba.lambda_practice;

/*
通过创建线程，对比lambda表达式的简便之处。
 */
public class Demo01 {

    public static void main(String[] args) {
        //方式一:老老实实创建Runnable接口子类
        //1.新建Runable接口的子类RSON,创建子类对象
        RSON rson = new RSON();
        //2.创建Thread类对象，构造方法传入子类对象rson
        Thread t1 = new Thread(rson);
        //3.开启线程
        t1.start();

        //方式二:用匿名内部类来创建Runnable接口实现类对象，省去单独建一个类了
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("方式二:简单打印一下");
                for (int i = 0; i < 10; i++) {
                    System.out.print(i);
                }
                System.out.println("\n==================");
            }
        });
        t2.start();

        //方式三: Runnable符合函数式接口，用lambda表达式简化
        Thread t3 = new Thread(() -> {
            System.out.println("方式三:简单打印一下");
            for (int i = 0; i < 10; i++) {
                System.out.print(i);
            }
            System.out.println("\n==================");
        });
        t3.start();
    }

}

class RSON implements Runnable {

    @Override
    public void run() {
        System.out.println("方式一:简单打印一下");
        for (int i = 0; i < 10; i++) {
            System.out.print(i);
        }
        System.out.println("\n==================");
    }
}

3. Lambda表达式的简化规则

如果参数只有一个，可以省略参数类型和小括号
如果方法体只有一行代码，可以省略{}，同时也要省略分号;
如果方法体只有return 一行代码，可以省略{}，同时也要省略分号; return

package com.note.functions_interface_test;
public class Test02 {
    public static void main(String[] args) {
        //接口的抽象方法无参数
        ((MineInterface) () -> 
                System.out.println("hello")
        ).method();

        //接口的抽象方法 有一个参数，可省略形参类型，形参小括号
        ((MineInterface) (int a) ->
                System.out.println("hello")
        ).method(10);
        ((MineInterface) (a) ->
                System.out.println("hello")
        ).method(10);
        ((MineInterface) a ->
                System.out.println("hello")
        ).method(10);

        //接口的抽象方法 有多个参数
        ((MineInterface) (int a, int b) -> {
            System.out.println("hello");
        }).method(10, 20);

        //方法体只有一条语句，可省略{ } 和 语句后的;
        ((MineInterface) (int a, int b) -> System.out.println("hello")).method(10, 20);
        
        //方法体只有一条return语句，可省略 {} return ;
        ((MineInterface) (int a, int b) -> 0).method(10, 20);
    }
}
//接口
@FunctionalInterface
interface MineInterface {
    void method();
    void method(int a);
    void method(int a, int b);
    int method(int a, int b);
}

4. Lambda注意

用匿名内部类时有时会爆这样的编译异常Variable used in lambda expression should be final or effectively final
原因: Lambda表达式中使用的变量应该是 final 或者有效的 final修饰的。

https://www.runoob.com/

package com.alibaba.lambda_practice;

/*
异常提示:Variable used in lambda expression should be final or effectively final
*/
public class Demo02 {
    public static void main(String[] args) {
        int n = 10;

        new Thread(new Runnable() {
            @Override
            public void run() {
                n = 20;
                System.out.println(n);
            }
        }).start();
    }
}

5. 匿名内部类与Lambda表达式的区别

匿名内部类可以用于接口、抽象类。Lambda表达式只能用于函数式接口
匿名内部类会自动生成一个接口的实现类.class文件，Lambda表达式Lambda的字节码文件会动态生成

第二章函数式接口

1. 函数式编程思想

面向对象过分强调“必须通过对象的形式来做事情”。找对象，通过对象调用方法。
而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做

2. 函数式接口

在Java中是指：有且仅有一个抽象方法的接口
接口可加注解@FunctionalInterface //加上注解,编译器会强制检查该接口是否符合函数式接口

package com.note.functions_interface_test;
@FunctionalInterface 
interface MyFunctionalInterface{
    void method();
}

3. 常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在java.util.function包中被提供。

3.1 Supplier接口

java.util.function.Supplier<T>接口，“供应商”
抽象方法T get()用来获取一个泛型参数指定类型的对象数据。
练习题：

package com.note.functions_interface_test.supplier_test;

import java.util.Arrays;
import java.util.function.Supplier;

public class Test {
    public static void main(String[] args) {
        //Supplier练习题求数组最大值
        int[] nums = {20, 3, 4, 5, 6};
        int m = getMethod(nums, () -> {
            int max = nums[0];
            for (int num : nums) {
                if(max < num){
                    max = num;
                }
            }
            return max;
        });
        System.out.println(m);
        
        //Supplier练习题求数组元素之和
        int s = getMethod(nums,()->{
			int sum = 0;
			for(int i = 0; i < nums.length ; ++i){
				sum += nums[i];
			}
			return sum;
		});
        System.out.println(s);
        
        //这样写的好处，将方法内具体怎么操作交给调用者决定
    }
    public static int getMethod(int[] nums, Supplier<Integer> supplier) {
        return supplier.get();
    }
}

3.2 Consumer接口

java.util.function.Consumer<T>接口消费一个数据
抽象方法void accept(T t)，意为消费一个指定泛型的对象数据。
练习题: 给你一个字符串,请按照大写的方式进行消费

package com.note.functions_interface_test.consumer_test;

import java.util.function.Consumer;

public class Test {
    public static void main(String[] args) {
        method("abcd", str -> System.out.println(str.toUpperCase()));
    }

    public static void method(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }
}

3.3 Function接口

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
抽象方法 R apply(T t)，根据类型T的参数获取类型R的结果。使用的场景例如：将String类型转换为Integer类型。
练习题：

package com.note.functions_interface_test.function_test;

import java.util.function.Function;

public class Test {
    public static void main(String[] args) {
        //将String类型的"hello" 转为Integer
        method("100",t->Integer.parseInt(t));
        method("100",Integer::parseInt); //方法引用 简化
    }

    public static <T> void method(T t,Function<T,Integer> function){
        function.apply(t);
    }
}

3.4 Predicate接口

java.util.function.Predicate<T>接口有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。
抽象方法：boolean test(T t) 用于条件判断的场景
练习题：

package com.note.functions_interface_test.predicate_test;

import java.util.function.Predicate;

public class Test {
    public static void main(String[] args) {
        //1.练习:判断字符串长度是否大于5
        System.out.println(method("abcde", (String str) -> str.length() > 5));
        System.out.println(method("abcdesf", str -> str.length() > 5));
        //2.练习:判断字符串是否包含"H"
        System.out.println(method("ABCDH", (String str) -> str.contains("H")));
        System.out.println(method("ABCDH", str -> str.contains("H")));
    }

    public static <T> boolean method(T t, Predicate<T> predicate) {
        return predicate.test(t);
    }
}