Java8新特性—四大内置函数式接口

Java8新特性——四大内置函数式接口

---

预备知识

背景

Lambda 的设计者们为了让现有的功能与 Lambda 表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。

什么是函数式接口？

函数式接口指的是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，这样的接口可以隐式转换为 Lambda 表达式。

但是在实践中，函数式接口非常脆弱，只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface，举个简单的函数式接口的定义：

@FunctionalInterface 
public interface GreetingService { 
    void sayMessage(String message); 
} 

Java7 只能通过匿名内部类进行编程，例如：

GreetingService greetService = new GreetingService() { 
 
    @Override 
    public void sayMessage(String message) { 
        System.out.println("Hello " + message); 
    } 
}; 
greetService.sayMessage("world"); 

Java8 可以采用 Lambda 表达方进行编程，例如：

GreetingService greetService = message -> System.out.println("Hello " + message); 
greetService.sayMessage("world"); 

目前 Java 库中的所有相关接口都已经带有这个注解了，实践上java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子!

@FunctionalInterface注解

Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。

正确例子，没有报错：

/**
 * @Description FunctionalInterface
 * @Author vchicken
 * @Date 2022/9/24 14:46
 */
@FunctionalInterface
public interface TestFunctionalInterface {

    void sayMessage(String message);

}

错误例子，接口中包含了两个抽象方法，违反了函数式接口的定义，Eclipse报错提示其不是函数式接口。

提醒：加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解知识提醒编译器去检查该接口是否仅包含一个抽象方法。

四大函数式接口

1.Function接口

什么是Function接口？

从Function接口的源代码，我们可以看出，JDK1.8之后才加入这个接口。Functional接口类中只有一个抽象方法待实现，符合函数式接口(指的是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口)，因此Function接口可以用Lambda表达式——这个方法就是apply。

从源码可以看出，入参和出参类型，用泛型动态指定。apply的具体逻辑就相当于是入参转化为出参的具体逻辑。也就相当于是y = f(x)这个里面的，映射法则f。具体逻辑需要我们用匿名内部类或者Lambda，写方法体来实现。因此这个接口又叫函数型接口。

下面我们来用代码举栗如何使用Function接口：

public class FunctionTest {

    public static void main(String[] args) {

        // 如果入参为null，则回参为0，否则返回入参的值作为出参
        Function<Integer, Integer> function1 = s -> s == null ? 0 : s;

        // 将入参的值+1后作为回参返回
        Function<Integer, Integer> function2 = s -> s + 1;

        // 如果入参为null，则回参为""，否则返回入参的值作为出参
        Function<String, String> function3 = s -> s == null ? "空的" : s;

        System.out.println(function1.apply(null));
        System.out.println(function1.apply(100));

        System.out.println(function2.apply(10));

        System.out.println(function3.apply(null));
        System.out.println(function3.apply("hello world!"));

        // andThen是先执行前面的操作，然后执行andThen之后的操作
        Function<Integer, Integer> first = x -> x * x;
        Function<Integer, Integer> after = y -> y * 2;

        System.out.println(first.apply(3));
        System.out.println(after.apply(3));
        int res = first.andThen(after).apply(4);
        System.out.println(res);
    }
}

执行结果

0
100
11
空的
hello world!
9
6
32

从上面的栗子我们可以看出：

Java把这些映射规则，也就是y = f(x)中的【f】抽象成了这个Function接口的apply逻辑。然后x和y，自变量和因变量，也就是入参出参，Java使用了扩展性更强的泛型参数类型，而不是固定Object入参出参。因为固定Object的话还要涉及到类型转换，还有可能报ClassCast异常，很麻烦

再看一个栗子：

/**
 * @author vchicken
 * @version 1.0
 * @description FunctionTest
 * @date 2022/11/10 12:10:06
 */
public class FunctionTest<T,R> {

    public static void main(String[] args) {
        FunctionTest<Integer, Integer> functionTest1 = new FunctionTest<>();
        System.out.println(functionTest1.functionTest(null, s -> s == null ? 0 : s));
        System.out.println(functionTest1.functionTest(100, s -> s == null ? 0 : s));

        System.out.println(functionTest1.functionTest(10, s -> s + 1));

        FunctionTest<String, String> functionTest2 = new FunctionTest<>();
        System.out.println(functionTest2.functionTest(null, s -> s == null ? "空的" : s));
        System.out.println(functionTest2.functionTest("hello world!", s -> s == null ? "空的" : s));
    }

    public R functionTest(T in,Function<T,R> function){
        return function.apply(in);
    }
}

执行结果：

0
100
11
空的
hello world!

结合两个栗子我们可以看出来：

我们可以使用Function接口来将同一个方法的处理逻辑抽象出来，在调用方法的时候，将处理逻辑以Lambda表达式的形式传入，实现同一个方法可以处理不同的代码逻辑，而且使用泛型来表示方法的出入参，可以避免不必要的类型转换和异常发生。@vchicken

Function接口在JDK中的应用

在JDK1.8中的新属性Stream中，就使用到了Function接口，看下面的源码：

通过一个例子来看看怎样使用map这个接口

public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(-1,0,1,2,3,4);
        Stream<Integer> stream1 = stream.map(integer -> integer + 1);
        stream1.forEach(System.out::println);
    }

执行结果：

0
1
2
3
4
5

案例：将数组中的数，依次平方，等到一个一个新的数组

List<Integer> myList = new ArrayList<>();
        myList.add(-2);
        myList.add(0);
        myList.add(1);
        myList.add(3);
        myList.add(5);
        myList.add(7);
        List<Integer> collect = myList.stream().map(integer -> integer*integer).collect(Collectors.toList());
        collect.forEach(System.out::println);

执行结果：

4
0
1
9
25
49

2.Consumer接口

什么是Consumer接口？

从源码可以看出，Consumer与Function类似，只有一个accept抽象方法待实现，只不过唯一的区别是，Consumer的accept使用void修饰，没有返回值，而Function有返回值。

Consumer接口又称为消费型接口，顾名思义，入参传入后，被accept方法消费掉了，什么都没得到。

举个栗子：

    public static void main(String[] args) {
        Consumer<Object> consumer1 = new Consumer<Object>() {
            @Override
            public void accept(Object o) {
                System.out.println("这次消费了:" + o.toString());
            }
        };

        consumer1.accept("100w元在双十一！这下穷死了！");

        Consumer<String> consumer2 = s -> System.out.println("这次消费了:" + s);

        consumer2.accept("120w元在双十二！又穷死了！");
    }

执行结果：

这次消费了:100w元在双十一！这下穷死了！
这次消费了:120w元在双十二！又穷死了！

同样的，我们可以提取公共方法为：

/**
 * @author vchicken
 * @version 1.0
 * @description ComsumerTest
 * @date 2022/11/10 17:14:11
 */
public class ConsumerTest<T> {

    public static void main(String[] args) {

        ConsumerTest<String> consumerTest = new ConsumerTest<>();
        consumerTest.accept("100w元在双十一！这下穷死了！", s -> System.out.println("这次消费了:" + s));
        consumerTest.accept("120w元在双十二！又穷死了！", s -> System.out.println("这次消费了:" + s));

    }

    public void accept(T in, Consumer<? super T> consumer) {
        consumer.accept(in);
    }
}

执行结果：

这次消费了:100w元在双十一！这下穷死了！
这次消费了:120w元在双十二！又穷死了！

Consumer接口在JDK中的应用

同样的，我们以Stream中的forEach为例，看下面的例子：

 Stream<Integer> stream = Stream.of(-1,0,1,2,3,4);
 stream.forEach(s-> System.out.println(s));

执行结果：

-1
0
1
2
3
4

同样的我们还可以使用方法引用来打印，效果一致

stream.forEach(System.out::println);

对于方法引用不了解的亲，也可以阅读这篇文章Java8 新特性 - 方法引用 @vchicken

3.Suppiler接口

什么是Suppiler接口？

既然我们上面说到了Consumer为消费型接口，按照惯例，那肯定有生产型接口或者也可以成为供给型接口——Supplier接口，看下图源码：

由源码我们可以看出，Supplier接口只有一个待实的get方法，属于无参有返回值的抽象方法。下面看一个例子：

 public static void main(String[] args) {

        // 生成一个字符串
        Supplier<String> supplier1 = () -> "abcde";

        // 生成一个随机数
        Supplier<Integer> supplier2 = () -> new Random().nextInt(10);

        // 产生一个运行时异常
        Supplier<RuntimeException> supplier3 = () -> new RuntimeException();

        System.out.println(supplier1.get());
        System.out.println(supplier2.get().intValue());
        System.out.println(supplier3.get());
    }

执行结果：

abcde
2
java.lang.RuntimeException

Supplier接口在JDK中的应用

generate方法返回一个无限连续的无序流，其中每个元素由提供的供应商(Supplier)生成。generate方法用于生成常量流和随机元素流。看下面例子：

public static void main(String[] args) {

        // 生成随机数
        Stream.generate(() -> new Random().nextInt(10));
        stream.forEach(System.out::println);

        // 生成随机布尔流
        Stream.generate(() -> new Random().nextBoolean())
                .forEach(System.out::println);

        // 生成常量流
        Stream.generate(() -> "Hello World!")
                .forEach(System.out::println);

    }

执行结果：

2
5
1
--- #略

true
false
true
--- #略

Hello World!
Hello World!
Hello World!
--- #略

由于generate返回无限连续流，为了限制流中元素的数量，我们可以使用Stream.limit方法

 public static void main(String[] args) {
	Stream.generate(() -> new Random().nextInt(10)).limit(3)
	   .forEach(e -> System.out.println(e));

	Stream.generate(() -> new Random().nextBoolean()).limit(3)
	   .forEach(e -> System.out.println(e));

	Stream.generate(() -> "Hello World!").limit(3)
	   .forEach(e -> System.out.println(e));
  }

执行结果：

3
6
3
true
false
false
Hello World!
Hello World!
Hello World!

4.Predicate接口

什么是Predicate接口？

Predicate接口又称为断言型接口，test()方法有参但是返回值类型是固定的boolean，看下面例子：

public static void main(String[] args) {
        Predicate<String> predicate = (s) -> s.length() > 0;

        // 测试字符串的长度是否>0
        System.out.println(predicate.test("hello"));

        // 结果取反
        System.out.println(predicate.negate().test("hello"));

        System.out.println("=====or / and======");
        System.out.println(predicate.test(""));
        // 增加或判断，二者满足其一则为true
        System.out.println(predicate.or(s -> s.equals("")).test(""));
        // 增加与判断，二者都满足则为true
        System.out.println(predicate.and(s -> s.equals("hello")).test(""));
        System.out.println(predicate.and(s -> s.equals("hello")).test("hello"));

        System.out.println("=====isEqual======");
        // 判断是否相等
        System.out.println(Predicate.isEqual("hello").test(""));
        System.out.println(Predicate.isEqual("hello").test("hello"));

        Predicate<Boolean> nonNull = Objects::nonNull;
        Predicate<Boolean> isNull = Objects::isNull;

        Predicate<String> isEmpty = String::isEmpty;
        Predicate<String> isNotEmpty = isEmpty.negate();

    }

执行结果：

true
false
=====or / and======
false
true
false
true
=====isEqual======
false
true

Predicate接口在JDK中的应用

Stream中的filter方法，用来过滤不满足条件的元素，使用Predicate传入过滤条件。看下面例子：

Stream<Integer> stream = Stream.of(-1, 0, 1, 2, 3, 4);
stream.filter(s -> s > 0).forEach(System.out::println);

执行结果：

1
2
3
4

总结

关于JDK1.8为什么要新增这四大内置函数式接口，其实就是Java的开发者将常用于代码的一些普遍场景抽象出来成为接口，而我们可以根据实际业务需求，实现这些接口的具体逻辑。通过lambda表达式的方式，也可以使得代码更加简洁。JDK中的函数式接口还有很多，但基本都是在四大函数式接口的基础之上加以拓展，有兴趣的童鞋可以自行研究。

四大函数式接口的比较

函数式接口	对应程序逻辑的抽象	具体场景
Function	程序中映射逻辑的抽象	比如我们写得很多的函数：接收入参，返回出参，方法代码块就是一个映射的具体逻辑。
Predicate	程序中判断逻辑的抽象	比如各种if判断，对于一个参数进行各种具体逻辑的判定，最后返回一个if else能使用的布尔值
Consumer	程序中的消费型逻辑的抽象	就比如Collection体系的ForEach方法，将每一个元素取出，交给Consumer指定的消费逻辑进行消费
Suppiler	程序中的生产逻辑的抽象	就比如最常用的，new对象，这就是一个很经典的生产者逻辑，至于new什么，怎么new，这就是Suppiler中具体逻辑的写法了

参考资料

• JDK8新特性第二篇：四大函数式接口【Function/Consumer/Supplier/Perdicate】、接口的扩展方法【default/static】