函数式接口

2021 年 7 月 5 日
筆記
JAVA

1、函数式接口概述
2、函数式接口作为方法的参数
3、函数式接口作为方法的返回值
4、常用函数式接口

1、函数式接口概述

函数式接口： 有且仅有一个抽象方法的接口

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

如何检测一个接口是不是函数式接口：@FunctionalInterface 注解放在接口定义的上方，如果接口是函数式接口编译通过，如果不是编译失败。

注意： 自定义函数式接口时，@FunctionalInterface 是可选的，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是建议加上该注解（规范）。

示例

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

2、函数式接口作为方法的参数

示例

public class Test_01 {
    public static void main(String[] args) {
        // 匿名内部类方式
        startRunable(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程启动");
            }
        });

        // lambda方式
        startRunable(() -> System.out.println(Thread.currentThread().getName() + " 线程启动"));
    }
	
    // Runnable类是一个函数s接口
    public static void startRunable(Runnable r) {
        new Thread(r).start();
    }
}

Thread-0 线程启动
Thread-1 线程启动

3、函数式接口作为方法的返回值

示例： 按照字符串长度正序排序

public class Test_02 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("bbb");
        list1.add("a");
        list1.add("cc");
        System.out.println("排序前 = " + list1);
        Collections.sort(list1);
        System.out.println("默认排序后 = " + list1);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("bbb");
        list2.add("a");
        list2.add("cc");
        System.out.println("排序前 = " + list2);
        Collections.sort(list2, getComparator());
        System.out.println("自定义排序后 = " + list2);
    }

    // 按照字符串长度正序排序，将Comparator函数式接口作为返回值

    // lambda方式
    public static Comparator<String> getComparator() {
        return (s1, s2) -> s1.length() - s2.length();
    }

    // 方法引用方式
    public static Comparator<String> getComparator2() {
        return Comparator.comparingInt(String::length);
    }

    // 匿名内部类方式
    public static Comparator<String> getComparator3() {
        return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
    }
}

排序前 = [bbb, a, cc]
默认排序后 = [a, bbb, cc]
排序前 = [bbb, a, cc]
自定义排序后 = [a, cc, bbb]

4、常用函数式接口

Java 8 在 java.util.function 包下预定义了大量的函数式接口供我们使用

4.1、Supplier 接口

Supplier 接口被称为生产型接口，如果指定了接口的泛型是什么类型，那么接口中的 get 方法就会生产什么类型的数据供我们使用，T – 出参类型，没有入参

方法	说明
T get()	该方法不需要参数，它会按照某种实现逻辑（由 Lambda 表达式实现）返回一个数据

示例

public class Test_03 {
    public static void main(String[] args) {
        String name = getString(() -> "勋悟空");
        System.out.println("name = " + name);

        Integer age = getInteger(() -> 500);
        System.out.println("age = " + age);
    }

    // 返回 String 类型数据
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }

    // 返回 Integer 类型数据
    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

    // 返回其它类型数据...
}

name = 勋悟空
age = 500

练习： 获取 int 数组最大值

public class Test_04 {
    public static void main(String[] args) {
        int arr[] = {5, 10, 7, 9, 8};
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println("maxValue = " + maxValue);
    }

    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

4.2、Consumer 接口

Consumer 接口被称为消费型接口，它消费的数据的数据类型由泛型指定，T – 入参类型，没有出参

方法	说明
void accept(T t)	对给定的参数执行此操作
default Consumer andThen(Consumer after)	依次执行此操作，然后执行 after 操作

示例

public class Test_05 {
    public static void main(String[] args) {
        // 打印该字符串，消费了一次
        operatorString("勋悟空", System.out::println);
        
        // 先打印该字符串，再获取该字符串的长度，消费了两次
        operatorString("勋悟空", System.out::println, s -> System.out.println(s.length()));
    }

    // 方法1：消费一个字符串数据
    public static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }

    // 方法2：对一个字符串数据连续消费两次
    public static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
        // con1.accept(name);
        // con2.accept(name);

        // 写法优化
        con1.andThen(con2).accept(name);
    }
}

勋悟空
勋悟空
3

练习

题目
- String[] strArray = {“林青霞,30”, “张曼玉,35”, “王祖贤,33”};
- 字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX”的格式将信息打印出来
要求
1. 把打印姓名的动作作为第一个 Consumer 接口的 Lambda 实例
2. 把打印年龄的动作作为第二个 Consumer 接口的 Lambda 实例
3. 将两个 Consumer 接口按照顺序组合到一起使用

public class Test_06 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        printInfo(strArray,
                  str -> System.out.print("姓名：" + str.split(",")[0]),
                  str -> System.out.println("，年龄：" + str.split(",")[1]));
    }

    public static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String s : strArray) {
            con1.andThen(con2).accept(s);
        }
    }
}

姓名：林青霞，年龄：30
姓名：张曼玉，年龄：35
姓名：王祖贤，年龄：33

4.3、Predicate 接口

Predicate 接口通常用于判断参数是否满足指定的条件，T – 入参类型，出参为 boolean 类型

方法	说明
boolean test(T t)	对给定的参数进行判断（判断逻辑由 Lambda 表达式实现），返回一个布尔值
default Predicate negate()	返回一个逻辑的否定，对应逻辑非（ ! ）
default Predicate and(Predicate other)	返回一个组合判断，对应短路与（&&）
default Predicate or(Predicate other)	返回一个组合判断，对应短路或（\|\|）

示例

public class Test_07 {
    public static void main(String[] args) {
        // 方法1
        boolean b1 = checkString1("hello", s -> s.length() > 6); // false
        boolean b2 = checkString1("hello", s -> s.length() < 6); // true
        System.out.println("b1 = " + b1);
        System.out.println("b2 = " + b2);
        System.out.println("--------");

        // 方法2
        boolean b3 = checkString2("hello", s -> s.length() > 6); // true
        boolean b4 = checkString2("hello", s -> s.length() < 6); // false
        System.out.println("b3 = " + b3);
        System.out.println("b4 = " + b4);
        System.out.println("--------");

        // 方法3
        boolean b5 = checkString3("hello", s -> s.length() > 6, s -> s.length() < 6); // false
        boolean b6 = checkString3("hello", s -> s.length() > 3, s -> s.length() < 6); // true
        System.out.println("b5 = " + b5);
        System.out.println("b6 = " + b6);
        System.out.println("--------");

        // 方法4
        boolean b7 = checkString4("hello", s -> s.length() > 6, s -> s.length() < 6); // true
        boolean b8 = checkString4("hello", s -> s.length() > 3, s -> s.length() < 6); // true
        System.out.println("b7 = " + b7);
        System.out.println("b8 = " + b8);
    }

    // 方法1：判断给定字符串是否满足要求
    public static boolean checkString1(String s, Predicate<String> pre) {
        return pre.test(s);
    }

    // 方法2：判断给定字符串是否满足要求（结果取反）
    public static boolean checkString2(String s, Predicate<String> pre) {
        return pre.negate().test(s);
    }

    // 方法3：对同一个字符串给出两个不同的判断条件，再把这两个结果做 短路与 运算，得出的结果做最终结果
    public static boolean checkString3(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
    }

    // 方法4：对同一个字符串给出两个不同的判断条件，再把这两个结果做 短路或 运算，得出的结果做最终结果
    public static boolean checkString4(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
}

b1 = false
b2 = true
--------
b3 = true
b4 = false
--------
b5 = false
b6 = true
--------
b7 = true
b8 = true

练习

题目
- String[] strArray = {“林青霞,30”, “西施,34”, “张曼玉,35”, “貂蝉,31”, “王祖贤,33”};
- 字符串数组中有多条信息，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，并遍历 ArrayList 集合
- 同时满足如下要求：姓名长度大于2，年龄大于33
分析
- 有两个判断条件，所以需要使用两个 Predicate 接口对条件进行判断
- 必须同时满足两个条件，所以可以使用 and 方法连接两个判断条件

public class Test_08 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        ArrayList<String> arrayList = filterData(strArray,
                                                 s -> s.split(",")[0].length() > 2,
                                                 s -> Integer.parseInt(s.split(",")[1]) > 33);
        for (String s : arrayList) {
            System.out.println("s = " + s);
        }
    }

    public static ArrayList<String> filterData(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        ArrayList<String> arrayList = new ArrayList<>();
        for (String s : strArray) {
            if (pre1.and(pre2).test(s)) {
                arrayList.add(s);
            }
        }
        return arrayList;
    }
}

s = 张曼玉,35

4.4、Function 接口

Function<T,R> 接口通常用于对参数进行处理，转换（处理逻辑由 Lambda 表达式实现），然后返回一个新的值，T – 入参类型，R – 出参类型

方法	说明
R apply(T t)	将此函数应用于给定的参数
default Function andThen(Function after)	返回一个组合函数，首先将该函数应用于输入，然后将 after 函数应用于结果

示例

public class Test_09 {
    public static void main(String[] args) {
        // 方法1
        convert("1", Integer::parseInt);
        
        // 方法2
        convert(1, i -> String.valueOf(i + 10));
        
        // 方法3
        convert("1", Integer::valueOf, s -> String.valueOf(s + 100));
    }

    // 方法1：将一个字符串转换为Integer类型并在控制台输出
    public static void convert(String s, Function<String, Integer> fun) {
        Integer i = fun.apply(s);
        System.out.println("i = " + i);
    }

    // 方法2：将一个Integer类型数据加上一个整数之后，转换为字符串并在控制台输出
    public static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println("s = " + s);
    }

    // 方法3：将一个字符串转换为Integer类型，把Integer类型数据加上一个整数之后，再转为字符串并在控制台输出
    public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println("ss = " + ss);
    }
}

i = 1
s = 11
ss = 101

练习

题目
- String s = “勋悟空,500”;
要求
1. 将字符串截取得到数字年龄部分
2. 将上一步的年龄字符串转换成为 Integer 类型数据
3. 将上一步的 Integer 数据加 23，得到一个 Integer 结果，在控制台输出
4. 请通过 Function 接口来实现函数拼接

public class Test_10 {
    public static void main(String[] args) {
        String monkey = "勋悟空,500";
        convert(monkey,
                s -> monkey.split(",")[1], // 将字符串截取得到数字年龄部分
                Integer::valueOf,          // 将上一步的年龄字符串转换成为Integer类型数据
                s -> s + 23);              // 将上一步的Integer数据加70，得到一个Integer结果
    }

    public static void convert(String s,
                               Function<String, String> fun1,
                               Function<String, Integer> fun2,
                               Function<Integer, Integer> fun3) {
        Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println("i = " + i);
    }
}

i = 523

Tags: JAVA

函数式接口

1、函数式接口概述

2、函数式接口作为方法的参数

3、函数式接口作为方法的返回值

4、常用函数式接口

4.1、Supplier 接口

4.2、Consumer 接口

4.3、Predicate 接口

4.4、Function 接口

VirMach 便宜 VPS

QNews

函数式接口

1、函数式接口概述

2、函数式接口作为方法的参数

3、函数式接口作为方法的返回值

4、常用函数式接口

4.1、Supplier 接口

4.2、Consumer 接口

4.3、Predicate 接口

4.4、Function 接口

分享此文：

Related Posts

fish shell 自动补全子命令

eyoucms破解授权/去版权插件

Linux目录结构

垃圾处理器-CMS

VirMach 便宜 VPS

QNews

熱門搜尋