java.util.function函数式接口应用举例

Java函数式接口介绍

Java8中有很多现成的函数式接口，它们在java.util.function包下，查看jdk文档，下图是部分的函数式接口：

前边学习Lambda知道，函数式接口只有一个抽象方法，下边打开函数接口Consumer源代码，如下：

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer<T> {
     void accept(T t);
     default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer接口只有一个void accept(T t);抽象方法。并且使用@FunctionalInterface注解标注它是一个函数式接口。（关于注解的知识点后边会介绍，这里只需要知道有@FunctionalInterface的接口都是函数式接口）

注意：如果某个接口只有一个抽象方法，但没有@FunctionalInterface标注，它也是函数接口。

这些函数接口是针对不同应用场景而设计，下边主要测试几种具有一定代表的函数接口，如下：

Function

1）Function源代码

查看Function的源代码，如下：

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Function<T, R> {
	R apply(T t);
	
	default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
	default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
     static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Function拥有一个抽象方法，两个默认方法，一个静态方法，接收泛型参数，一个是apply方法的输入参数类型，一个是apply方法的输出结果类型。

Function主要用于转换作用，输入一个类型的参数，输出另一个类型的结果。

2）apply方法测试

package com.pbteach.javase.oop.lambda.test2;

import java.util.function.Function;

/**
 * 测试java.util.function.Function接口
 * @author 攀博课堂(www.pbteach.com)
 * @version 1.0
 **/
public class TestFunction {

    public static void main(String[] args) {
        testApply();

    }

    public static void testApply(){
        Function<String,Integer> function1 = (String p1)->{
            return p1.length();
        };
        //简写
        Function<String,Integer> function2 = p1->p1.length();

        System.out.println(function1.apply("www.pbteach.com"));
        System.out.println(function2.apply("www.pbteach.com"));
    }
}

输出：

15
15

3）andThen方法测试

Function接口还有两个默认方法：andThen、compose，下边测试andThen方法，它的源代码如下：

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

andThen方法传入一个Function接口实例，返回一个Function接口实例。它可以实现先执行当前Function接口实现的apply方法，再执行after实例的apply方法，实现前后执行两个操作的功能。

测试代码如下：

    //测试andThen方法
    public static void testAndThen(){
        //前边的操作
        Function<String,String> before = s1 -> "www."+s1;

        //后边的操作
        Function<String,String> after = s1 -> s1 + ".com";
        //调用andThen方法分别执行前、后两个操作
        String pbteach = before.andThen(after).apply("pbteach");
        System.out.println(pbteach);

    }

输出：

www.pbteach.com

画图分析：

BiFunction

下边测试其中一个接口BiFunction<T,U,R>，查看API文档如下：
本接口定义三个泛型参数：T、U、R，抽象方法有两个参数和返回值，查看源代码如下：

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
    ...

使用Lambda测试此接口，Lambda要有两个参数及返回值，代码如下：

package com.pbteach.javase.oop.lambda.test2;

import java.util.function.BiFunction;

/**
 * 测试BiFunction
 * @author 攀博课堂(www.pbteach.com)
 * @version 1.0
 **/
public class TestBiFunction {

    public static void main(String[] args) {
        //求和
        BiFunction<Integer,Integer,Integer> fun1 = (x,y)->x+y;
        //乘积
        BiFunction<Integer,Integer,Integer> fun2 = (x,y)->x*y;
        System.out.println(operate(fun1,1,2));
        System.out.println(operate(fun2,1,2));
    }

    //两个数运算
    public static int operate(BiFunction<Integer,Integer,Integer> fun,int n1,int n2){
        return fun.apply(n1,n2);
    }
}

输出：

3
2

Consumer

Consumer介绍

查看Consumer接口的源代码，如下：

package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {

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

Consumer的抽象方法void accept(T t)只接收一个参数，没有返回值。Consumer接口是一个消费接口，接收一个数据进行消费。

Consumer测试

有一个整数数列，下边使用Consumer接口进行消费，测试代码如下：

package com.pbteach.javase.oop.lambda.test2;

import java.util.function.Consumer;

/**
 * 测试Consumer接口
 * @author 攀博课堂(www.pbteach.com)
 * @version 1.0
 **/
public class TestConsumer {

    static int[] datas = {1,2,3,4,5,6,7};
    static int sum = 0;
    public static void main(String[] args) {
        //消费方式是输出数据
        Consumer<Integer> fun1 = n -> System.out.println(n);
        //判断奇偶
        Consumer<Integer> fun2 = n -> {
            if(n % 2 ==0){
                System.out.println(n + "是偶数");
            }else{
                System.out.println(n + "是奇数");
            }
        };
        //求累加和
        Consumer<Integer> fun3 = n -> sum+=n;

        consumer(fun1,datas);
        consumer(fun2,datas);
        consumer(fun3,datas);
        System.out.println("sum="+sum);

    }

    public static void consumer(Consumer<Integer> fun,int[] datas){
        for (int i = 0; i < datas.length; i++) {
            fun.accept(datas[i]);
        }
    }
}

输出：

1
2
3
4
5
6
7
1是奇数
2是偶数
3是奇数
4是偶数
5是奇数
6是偶数
7是奇数
sum=28

更多函数式接口应用

请参考Lambda函数式接口教程（全免费）：http://www.pbteach.com/course/20/index.html