chapter24_【函数式接口】-笔记

day12【函数式接口】-笔记

day12【函数式接口】

主要内容

自定义函数式接口

函数式编程

常用函数式接口

教学目标

能够使用@FunctionalInterface注解

能够自定义无参无返回函数式接口

能够自定义有参有返回函数式接口

能够理解Lambda延迟执行的特点

能够使用Lambda作为方法的参数

能够使用Lambda作为方法的返回值

能够使用Supplier函数式接口

能够使用Consumer函数式接口

能够使用Function函数式接口

能够使用Predicate函数式接口

第一章函数式接口

1.1 概念

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

1.2 格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息); 
    // 其他非抽象方法内容
}

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单

public interface MyFunctionalInterface { 
    void myMethod();
}

1.3 @FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。

该注解可用于一个接口的定义上

@FunctionalInterface public interface MyFunctionalInterface {
    void myMethod();
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注

意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

小结

函数接口：有且只有一个抽象方法的接口，称之为函数接口

当然接口中可以包含其他方法（默认、抽象、私有）

@FunctionalInterface注释

作用：可以检测接口是否是一个函数式接口

是：编译成功
否：编译失败（接口中没有抽象方法或者抽象方法的个数大于一个）

示例代码

接口

@FunctionalInterface
public interface MyFunctionalInterface {

        public abstract void method();


}

接口实现类

@override注释
 检查方法是否为重写的方法
 是：编译成功
 否：编译失败
 */
public abstract class FunctionalInterfaceImpl implements  MyFunctionalInterface {
    @Override
    public void method(){

    }

}

1.4 自定义函数式接口

函数接口的使用

public class Demo {
    /**
     定义一个方法，参数使用函数式接口MyFunctionalInterface
      */
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        // 调用show方法，方法的参数类一个接口，所以可以传递接口的实现类对象
        show(new MyFunctionalInterfaceImpl() {
            @Override
            public void method() {
                System.out.println("接口的实现列对象");
            }
        });
        // 调用show方法，方法的参数类一个接口，所以可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类的抽象方法");
            }
        });

        //  调用show，方法的参数是一个接口，所以我们可以使用Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });
        // 简化Lambda表达式
        show(()-> System.out.println("简化的Lambda表达式"));
    }
}

第二章函数式编程

在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。

下面我们做一个初探。

2.1 Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以

作为解决方案，提升性能。

性能浪费的日志案例

注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。

一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

发现以下代码存在的一些性能浪费的问题

调用showLog方法，传递的第二个参数是一个拼接的字符串

先把字符串拼接好，然后调用showLog方法

如果showLog传递的不是1级

那么就不是如此拼接后的字符串

所以字符串白拼接了，存在了浪费

private static void showLog(int level,String message){
    if(level == 1){
        System.out.println(message)
    }
} 
public static void main(String[] args){
    // 定义三个日志信息
    String msg1 = "Hello";
    String msg2 = "World";
    String msg3 = "Java";
    showLog(1,msg1+msg2+msg3);
}

这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug("变量{}的取值为{}。", "os", "macOS") ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

体验Lambda的更优写法

使用Lambda必然需要一个函数式接口：

@FunctionalInterface
public interface MessageBuilder {
    // 定义一个拼接字符串消息的抽象方法，返回被拼接的消息
    public abstract String builderMessage();
}

然后对showLog方法进行改造

public class Demo02Lambda {
    // 定义一个显示日志的方法，方法的参数传递日志的等级和MessageBudile接口
    public static void showLog(int level,MessageBuilder mb){
        // 对日志的等级进行判断，如果是1级，则调用MessageBuilder接口中的方法builderMessage
        if (level == 1){
            System.out.println(mb.builderMessage());
        }

    }
    public static void main(String[] args) {
        // 定义三个日志信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        // 调用showLog方法参数MessageBuilder是一个函数式接口所以可以传递Lambda表达式
        showLog(1,()->{
            // 返回一个拼接好的字符串
            return msg1+msg2+msg3;
        });
/**
    使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
    只有满足条件，日志的等级为1级
       才会调用接口MessageBuilder方法中的builderMessage
        才会进行字符串拼接
    如果条件不满足，日志的等级不是一级
        那么MessageBuilder接口中的方法builderMessage也不会执行
        所以拼接字符串也不会执行
    所以不存在性能浪费
 */
    }
}

从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法来完成。而是否调用其所在方法是在条件判断之后才执行

2.2 使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。

例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class Demo04Runnable {
    private static void startThread(Runnable task) {
        new Thread(task).start();
    }
    public static void main(String[] args) { 
        startThread(() ‐> System.out.println("线程任务执行！")); 
    }
}

类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator { 
    private static Comparator<String> newComparator() { 
        return (a, b) ‐> b.length() ‐ a.length();
    }
    public static void main(String[] args) { 
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array)); 
        Arrays.sort(array, newComparator()); 
        System.out.println(Arrays.toString(array));
    }
}

其中直接return一个Lambda表达式即可。

第三章常用函数式接口

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

下面是最简单的几个接口及使用示例。

3.1 Supplier接口

java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。

由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

Supplier接口被称为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据

public class Demo01Supplier {
    // 定义一个方法，方法的参数传递Supplier<T>接口，泛型执行String，get方法就会返回一个String类型的数据
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
    public static void main(String[] args) {
        String s = getString(()->{
            return "雷神";
        });
        System.out.println(s);

        // 优化Lambda表达式
        String s2 = getString(()->"火女");
        System.out.println(s2);
    }
}

3.2 练习：求数组元素最大值

题目

使用 Supplier 接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。提示：接口的泛型请使用 java.lang.Integer 类。

示例代码

public class Demo02Test {
    // 定义一个方法，用于获取int类型数组中元素的最大值，方法的参数supplier接口，泛型使用integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        // 定义一个int类型的数组，并赋值
        int[] arr = {66,669,663352,-20,12453,1111};
        // 调用getMax方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        int maxValue = getMax(()->{
            // 获取数组的最大值，并返回
            // 定义一个变量，把数组的中的第一个元素赋值给该变量，记录数组中元素的最大值
            int max = 0;
            for (int i : arr) {
                // 使用其他的元素和最大值个比较
                if (i>max){
                    max = i;
                }
            }
            // 返回最大值
            return max;
        });
        System.out.println("数组中元素的最大值是："+maxValue);
    }
}

3.3 Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，

其数据类型由泛型决定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。

Cousumer接口是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据

至于具体怎么消费（使用），需要自定义（输出，计算。。。）

public class Demo01Counsumer {
    /**
        定义一个方法
        方法的参数传递一个字符串的姓名
        方法的参数传递Consumer接口，泛型使用String类型
        可以使用Consumer接口消费字符串姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        // 调用method方法，传递字符串姓名，方法的另一个参数是Consumer接口，是一个函数式接口，所以可以传递Lambda表达式
        method("凤凰",(String name)->{
            // 对传递的字符串进行消费
            // 消费的方法直接输出字符串
            System.out.println(name);

            // 消费的方式：那字符串进行反转输出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，

然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen

下面是JDK的源代码

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) ‐> { accept(t);after.accept(t);
                    }; 
}

备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出

NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦

public class Demo02AndThen {
    // 定义一个方法，方法传递一个字符串和两个Consumer接口，consumer接口的泛型使用字符串
    public static void mehtod(String s, Consumer<String> con1,Consumer<String> con2){
        con1.accept(s);
        con2.accept(s);

        // 或者使用andThen方法，把两个Consumer接口连接到一起，再消费数据
        con1.andThen(con2).accept(s);
    }

    public static void main(String[] args) {
        // 调用method方法，传递一个字符串，两个Lambda表达式
        mehtod("Hello",
                (t)->{
                    // 消费方式：把转字符串转换为大写字母
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    // 消费方式：把转字符串转换为小写字母
                    System.out.println(t.toLowerCase());
                });
    }
}

3.4 练习：格式化打印信息

题目

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。

public static void main(String[] args) {
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
}

示例代码

public class Demo03Test {
    public static void method(String[] arr, Consumer<String> con1,Consumer<String> con2){
        // 遍历字符串数组
        for (String message : arr) {
            // 使用andThen方法连接两个Consumer接口，消费字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        // 定义一个字符串型的数组
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
        // 调用method方法，传递一个字符串数组，和两个Lambda表达式
        method(array,(message)->{
            // 消费方式：对s进行分隔，获取姓名，按照指定的格式输出
            String name = message.split(",")[0];
            System.out.print("姓名："+name);
        },(message)->{
            // 消费方式：对s进行分隔，获取年龄，按照指定的格式输出
            String age = message.split(",")[1];
            System.out.println(".年龄："+age+"。");
        });
    }
}

3.5 Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用

java.util.function.Predicate 接口。

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景

public class Demo01Predicate {
    /**
        定义一个方法
        参数传递一个String类型的字符串
        传递一个Predicate接口，泛型使用String
        使用Predicate中的方法test对字符串进行判断，并把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        // 定义一个字符串
        String s = "abcdef";
        // 调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式
        boolean b = checkString(s,(String str)->{
           // 对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把判断的结果返回
            return str.length()<3;
        });
        System.out.println(b);
        // 优化Lambda表达式
        boolean c = checkString(s,str-> str.length()>5);
        System.out.println(c);

    }
}

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other); return (t) ‐> test(t) && other.test(t);
}

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

import java.util.function.Predicate; public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.and(two).test("Helloworld"); 
        System.out.println("字符串符合要求吗：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默认方法：or

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) || other.test(t);
}

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变：

import java.util.function.Predicate; public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.or(two).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默认方法：negate

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法 negate 的JDK源代码为：

default Predicate<T> negate() {
    return (t) ‐> !test(t);
}

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：

import java.util.function.Predicate;
public class Demo17PredicateNegate {
    private static void method(Predicate<String> predicate) {
        boolean veryLong = predicate.negate().test("HelloWorld"); System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args) {
        method(s ‐> s.length() < 5); 
    }
}

3.6练习：集合信息筛选

题目

数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合

ArrayList 中，需要同时满足两个条件：

必须为女生；
姓名为4个字

public class DemoPredicate { public static void main(String[] args) {
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
}
                           }

示例代码

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class DemoPredicate {
    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        List<String> list = filter(array, s ‐> "女".equals(s.split(",")[1]), s ‐> s.split(",")[0].length() == 4);
        System.out.println(list);
    }
    private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {
        List<String> list = new ArrayList<>(); for (String info : array) { if (one.and(two).test(info)) { list.add(info); } }return list;
    }
}

3.7 Function接口

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法：apply

Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。使用的场景例如：将 String 类型转换为 Integer 类型。

import java.util.function.Function;
public class Demo11FunctionApply {
    private static void method(Function<String, Integer> function) { 
        int num = function.apply("10");
        System.out.println(num + 20);
    }
    public static void main(String[] args) {
        method(s ‐> Integer.parseInt(s));
    }
}

当然，最好是通过方法引用的写法。

默认方法：andThen

Function 接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after); return (T t) ‐> after.apply(apply(t));
}

该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

import java.util.function.Function;
public class Demo12FunctionAndThen {
    private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
        int num = one.andThen(two).apply("10");                  System.out.println(num + 20);                                              }
    public static void main(String[] args) { method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
                                           }
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。

请注意，Function的前置条件泛型和后置条件泛型可以相同。

3.8 练习：自定义函数模型拼接

题目

请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：

String str = "赵丽颖,20";

将字符串截取数字年龄部分，得到字符串；
将上一步的字符串转换成为int类型的数字；
将上一步的int数字累加100，得到结果int数字。

示例代码

import java.util.function.Function;
public class DemoFunction {
    public static void main(String[] args) {
        String str = "赵丽颖,20";
        int age = getAgeNum(str, s ‐> s.split(",")[1], s ‐>Integer.parseInt(s), n ‐> n += 100);
        System.out.println(age); 
    }
    private static int getAgeNum(String str, Function<String, String> one, Function<String, Integer> two, Function<Integer, Integer> three) {
        return one.andThen(two).andThen(three).apply(str);
    }
}

posted @ 2020-04-21 07:37 _Anke 阅读(92) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

_Anke

chapter24_【函数式接口】-笔记

day12【函数式接口】-笔记

主要内容

教学目标

第一章 函数式接口

1.1 概念

1.2 格式

1.3 @FunctionalInterface注解

小结

示例代码

1.4 自定义函数式接口

第二章 函数式编程

2.1 Lambda的延迟执行

性能浪费的日志案例

体验Lambda的更优写法

2.2 使用Lambda作为参数和返回值

第三章 常用函数式接口

3.1 Supplier接口

3.2 练习：求数组元素最大值

3.3 Consumer接口

默认方法：andThen

3.4 练习：格式化打印信息

3.5 Predicate接口

抽象方法：test

默认方法：and

默认方法：or

默认方法：negate

3.6练习：集合信息筛选

3.7 Function接口

抽象方法：apply

默认方法：andThen

3.8 练习：自定义函数模型拼接

公告

第一章函数式接口

第二章函数式编程

第三章常用函数式接口