0%

玩转 Java8Stream (二、函数式接口)

发表于 分类于 ， ， 阅读次数： Valine：
本文字数： 16k 阅读时长 ≈ 14 分钟

函数式接口是伴随着 Stream 的诞生而出现的，Java8Stream 作为函数式编程的一种具体实现，开发者无需关注怎么做，只需知道要做什么，各种操作符配合简洁明了的函数式接口给开发者带来了简单快速处理数据的体验。

1. 函数式接口

什么是函数式接口？简单来说就是只有一个抽象函数的接口。为了使得函数式接口的定义更加规范，java8 提供了@FunctionalInterface 注解告诉编译器在编译器去检查函数式接口的合法性，以便在编译器在编译出错时给出提示。为了更加规范定义函数接口，给出如下函数式接口定义规则：

  • 有且仅有一个抽象函数
  • 必须要有 @FunctionalInterface 注解
  • 可以有默认方法

可以看出函数式接口的编写定义非常简单，不知道大家有没有注意到，其实我们经常会用到函数式接口，如 Runnable 接口，它就是一个函数式接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

过去我们会使用匿名内部类来实现线程的执行体：

1
2
3
4
5
6
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello FunctionalInterface");
    }
}).start();

现在我们使用 Lambda 表达式，这里函数式接口的使用没有体现函数式编程思想，这里输出字符到标准输出流中，起到了简化代码的作用。

1
2
3
new Thread(() -> {
    System.out.println("Hello FunctionalInterface");
}).start();

Java8 util.function 包下自带了 43 个函数式接口，大体分为以下几类：

  • Consumer 消费接口
  • Function 功能接口
  • Operator 操作接口
  • Predicate 断言接口
  • Supplier 生产接口

其他接口都是在此基础上变形定制化罢了。

2. 函数式接口详细介绍

这里只介绍最基础的函数式接口，至于它的变体只要明白了基础自然就能够明白

2.1 Consumer

消费者接口，就是用来消费数据的。

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
26
27
@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer 接口中有 accept 抽象方法，accept 接受一个变量，也就是说你在使用这个函数式接口的时候，给你提供了数据，你只要接收使用就可以了；

andThen 是一个默认方法，接受一个 Consumer 类型，当你对一个数据使用一次还不够爽的时候，你还能再使用一次，当然你其实可以爽无数次，只要一直使用 andThan 方法。

2.2 Function

何为 Function 呢？比如电视机，给你带来精神上的愉悦，但是它需要用电啊，电视它把电转换成了你荷尔蒙，这就是 Function，简单电说，Function 提供一种转换功能。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     * 将 T 类型数据转换为 R 类型数据
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Function 接口最主要的就是 apply 函数，apply 接受T类型数据并返回 R 类型数据，就是将 T 类型的数据转换成 R 类型的数据，它还提供了compose、andThen、identity 三个默认方法，compose 接受一个 Function，andThen 也同样接受一个 Function，这里的a ndThen 与Consumer 的 andThen 类似，在 apply 之后在 apply 一遍，compose 则与之相反，在 apply 之前先 apply（这两个 apply 具体处理内容一般是不同的），identity 是个静态方法，返回一个输出跟输入一样的 Lambda 表达式对象。

1
2
3
4
5
6
public void testIdentity() {
    Stream<String> stream = Stream.of("I", "love", "you", "too");
    Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length));
    // Map<String, Integer> map = stream.collect(Collectors.toMap( t -> t, String::length));
    System.out.println(map); // {love=4, too=3, I=1, you=3}
}

2.3 Operator

可以简单理解成算术中的各种运算操作，当然不仅仅是运算这么简单，因为它只定义了运算这个定义，但至于运算成什么样你说了算。由于没有最基础的 Operator，这里将通过 BinaryOperator、IntBinaryOperator 来理解 Operator 函数式接口，先从简单的 IntBinaryOperator开始。

2.3.1 IntBinaryOperator

从名字可以知道，这是一个二元操作，并且是 int 类型的二元操作，那么这个接口可以做什么呢，除了加减乘除，还可以可以实现平方（两个相同 int 数操作起来不就是平方吗），还是先看看它的定义吧：

1
2
3
4
5
6
7
8
9
10
11
12
@FunctionalInterface
public interface IntBinaryOperator {

    /**
     * Applies this operator to the given operands.
     *
     * @param left the first operand
     * @param right the second operand
     * @return the operator result
     */
    int applyAsInt(int left, int right);
}

IntBinaryOperator 接口内只有一个 applyAsInt 方法，其接收两个 int 类型的参数，并返回一个 int 类型的结果，其实这个跟 Function 接口的 apply 有点像，但是这里限定了，只能是 int 类型。

2.3.2 BinaryOperator

BinaryOperator 二元操作，看起来它和 IntBinaryOperator 是父子关系，实际上这两者没有半点关系，但他们在功能上还是有相似之处的：

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
26
27
28
29
30
31
32
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    /**
     * Returns a {@link BinaryOperator} which returns the lesser of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the lesser of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    /**
     * Returns a {@link BinaryOperator} which returns the greater of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the greater of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

BinaryOperator 是 BiFunction 生的，而 IntBinaryOperator 是从石头里蹦出来的，BinaryOperator 自身定义了minBy、maxBy 默认方法，并且参数都是 Comparator，就是根据传入的比较器的比较规则找出最小最大的数据。

2.4 Predicate

断言、判断，对输入的数据根据某种标准进行评判，最终返回 boolean值：

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Predicate 的 test 接收 T 类型的数据，返回 boolean 类型，即对数据进行某种规则的评判，如果符合则返回 true，否则返回 false；Predicate 接口还提供了 and、negate、or，与 取反 或等，isEqual 判断两个参数是否相等等默认函数。

2.5 Supplier

生产、提供数据：

1
2
3
4
5
6
7
8
9
10
@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

非常 easy，get 方法返回一个 T 类数据，可以提供重复的数据，或者随机种子都可以，就这么简单。

3. 函数式接口实战

3.1 Consumer

Consumer 用的太多了，不想说太多，forEach 方法接收一个 Consumer 类型参数，如下：

1
2
3
4
5
6
public class Main {
    public static void main(String[] args) {
      	Stream.of(1,2,3,4,5,6)
                .forEach(integer -> System.out.println(integer)); //输出1，2，3，4，5，6
    }
}

3.2 Function

1）转换，将字符串转成长度，map 方法接收一个 Function 类型参数：

1
2
3
4
5
6
@Test
public void testFunction() {
    Stream.of("hello", "FunctionalInterface")
        .map(e -> e.length())
        .forEach(System.out::println);
}

2）运算

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
26
27
28
29
public class FunctionTest {

    public static void main(String[] args) {

        Function<Integer, Integer> square = integer -> integer * integer; //定义平方运算

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        list.stream()
                .map(square.andThen(square)) //四次方
                .forEach(System.out::println);

        System.out.println("------");

        list.stream()
                .map(square.compose(e -> e - 1)) //减一再平方
                .forEach(System.out::println);

        System.out.println("------");

        list.stream().map(square.andThen(square.compose(e->e/2))) //先平方然后除2再平方
                .forEach(System.out::println);

    }
}

结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
16
81
256
------
0
1
4
9
------
0
4
16
64

3.3 Operator

1）BinaryOperator

这里实现找最大值：

1
2
3
4
5
6
@Test
public void testBinaryOperatorMaxValue() {
    Stream.of(2, 4, 5, 6, 7, 1)
        .reduce(BinaryOperator.maxBy(Comparator.comparingInt(Integer::intValue)))
        .ifPresent(System.out::println);
}

其中 comparingInt 方法返回一个 Comparator 比较器，并内部实现了 Integer 之间的比较：

1
2
3
4
5
public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}

当然我们也可以自定义比较器，将上述测试方法改造如下：

1
2
3
4
5
6
@Test
public void testBinaryOperatorMaxValue() {
    Stream.of(2, 4, 5, 6, 7, 1)
        .reduce(BinaryOperator.maxBy( (e1, e2) -> e1.compareTo(e2) ))
        .ifPresent(System.out::println);
}

2）IntOperator

这里实现累加功能：

1
2
3
4
5
6
7
@Test
public void testIntOperator() {
    IntBinaryOperator intBinaryOperator = (e1, e2) -> e1 + e2; //定义求和二元操作
    IntStream.of(2, 4, 5, 6, 7, 1)
        .reduce(intBinaryOperator)
        .ifPresent(System.out::println); // 25
}

3.4 Predicate

筛选出大于 0 最小的两个数，filter 方法接收一个 Predicate 类型入参：

1
2
3
4
5
6
7
8
@Test
public void testPredicate() {
    IntStream.of(200, 45, 89, 10, -200, 78, 94)
        .filter(e -> e > 0) //过滤小于0的数
        .sorted() //自然顺序排序
        .limit(2) //取前两个
        .forEach(System.out::println);
}

3.5 Supplier

这里一直生产2这个数字，为了能停下来，使用 limit。generate 方法接收一个 Supplier 类型入参：

1
2
3
4
5
6
@Test
public void testSupplier() {
    Stream.generate(() -> 2)
        .limit(10)
        .forEach(System.out::println);
}

4. 总结

Java8 的 Stream 基本上都是使用 util.function 包下的函数式接口来实现函数式编程的，而函数式接口也就只分为 Function、Operator、Consumer、Predicate、Supplier 这五大类，只要能理解掌握最基础的五大类用法，其他变种也能触类旁通。

文章来源：https://www.jianshu.com/p/2338cabc59e1

------ 本文结束------