跟着老侯玩编程
  • Java
  • 基础篇
舞动的代码
2022-05-17
目录

常用API之函数式接口

# 常用函数式接口

JDK 提供了大量常用的函数式接口以丰富 Lambda 的典型使用场景，它们主要在 java.util.function 包中被提供。下面是最简单的几个接口及使用示例。

# Supplier 接口

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的 Lambda 表达式需要 “对外提供” 一个符合泛型类型的对象数据


import java.util.function.Supplier;

public class Demo08Supplier {
    private static String getString(Supplier<String> function) {
        return function.get();
    }

    public static void main(String[] args) {
        String msgA ="Hello";
        String msgB = "World";
        System.out.println(getString(() ‐> msgA + msgB));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

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

# 示例代码


public class Demo02Test {
    // 定一个方法, 方法的参数传递 Supplier, 泛型使用 Integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        int arr[] = {2,3,4,52,333,23};

        // 调用 getMax 方法, 参数传递 Lambda
        int maxNum = getMax(()‐>{
           // 计算数组的最大值
           int max = arr[0];
           for(int i : arr){
               if(i>max){
                   max = i;
               }
           }
           return max;
        });
        System.out.println(maxNum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Consumer 接口

java.util.function.Consumer <T> 接口则正好与 Supplier 接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

# 抽象方法：accept

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


import java.util.function.Consumer;

public class Demo09Consumer {
    private static void consumeString(Consumer<String> function) {
        function.accept("Hello");
    }

    public static void main(String[] args) {
        consumeString(s ‐> System.out.println(s));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当然，更好的写法是使用方法引用。

# 默认方法：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);
    };
}
1
2
3
4
5
6
7
8
9

备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为 null 时主动抛出 NullPointerException 异常。这省去了重复编写 if 语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个 Lambda 表达式即可，而 andThen 的语义正是 "一步接一步" 操作。例如两个步骤组合的情况：


import java.util.function.Consumer;

public class Demo10ConsumerAndThen {
    private static void consumeString(Consumer<String> one, Consumer<String> two){
        one.andThen(two).accept("Hello");
    }

    public static void main(String[] args) {
        consumeString(s ‐> System.out.println(s.toUpperCase()),
            s ‐> System.out.println(s.toLowerCase()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果将会首先打印完全大写的 HELLO，然后打印完全小写的 hello。当然，通过链式写法可以实现更多步骤的组合。

# 练习：格式化打印信息

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


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

# 示例代码


import java.util.function.Consumer;

public class DemoConsumer {
    public static void main(String[] args) {
        String[] array = {"迪丽热巴, 女", "古力娜扎, 女", "马尔扎哈, 男"};
        printInfo(s ‐> System.out.print("姓名：" + s.split(",")[0]),
                  s ‐> System.out.println("。性别：" + s.split(",")[1] + "。"),
                  array);
    }

    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
        for (String info : array) {
            one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Predicate 接口

有时候我们需要对某种类型的数据进行判断，从而得到一个 boolean 值结果。这时可以使用 java.util.function.Predicate<T> 接口。

# 抽象方法：test

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


import java.util.function.Predicate;

public class Demo15PredicateTest {private static void method(Predicate<String> predicate) {
    	boolean veryLong = predicate.test("HelloWorld");
        System.out.println("字符串很长吗：" + veryLong);
    }

    public static void main(String[] args) {
        method(s ‐> s.length()> 5);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

条件判断的标准是传入的 Lambda 表达式逻辑，只要字符串长度大于 5 则认为很长。

# 默认方法：and

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


default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) && other.test(t);
}
1
2
3
4
5
6

如果要判断一个字符串既要包含大写 “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"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 默认方法：or

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


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

如果希望实现逻辑 “字符串包含大写 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"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

# 默认方法：negate

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


default Predicate<T> negate() {
    return (t) ‐> !test(t);
}
1
2
3
4
5

从实现中很容易看出，它是执行了 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 练习：集合信息筛选

数组当中有多条 “姓名 + 性别” 的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，需要同时满足两个条件：

  • 必须为女生；

  • 姓名为 4 个字。


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

# 示例代码


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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

# 默认方法：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));
}
1
2
3
4
5

该方法同样用于 “先做什么，再做什么” 的场景，和 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

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

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

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

请使用 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
泛型编程
常用API

← 常用API→

Theme by Vdoing | Copyright © 2013-2023 冀ICP备16006233号-1
×