怎么样能把函数式接口用好

开篇

JDK8大家知道并使用的特性莫过于Lambda,这个很多人会用,比如Stream流,但都是简单浅显的使用,比如调用集合的Stream API等,但不会自己定义函数接口或API,今天通过几个案例来提高下对Java 中函数式编程的使用。

案例演示

函数接口说明

接口输入参数返回类型说明
UnaryOperatorTT一元函数,输入输出类型相同
PredicateTboolean断言
ConsumerT/消费一个数据,只有输入没有输出
Function<T,R>TR输入 T 返回 R,有输入也有输出
Supplier/T提供一个数据,没有输入只有输出
BiFunction<T,U,R>(T,U)R两个输入参数
BiPredicate<L, R>(L,R)boolean两个输入参数
BiConsumer<T, U>(T,U)void两个输入参数
BinaryOperator(T,T)T二元函数,输入输出类型相同

案例一

Function<Integer, Integer> times2 = e -> e * 2;
Function<Integer, Integer> squared = e -> e * e;
// 先执行参数,再执行调用者
/*
 * 1. 4 * 4 = 16 16 * 2 = 32
 */
System.out.println("result: " + times2.compose(squared).apply(4)); // 32
/*
 * 先执行调用者: 4 * 2 = 8 再执行then传入的function 8 * 8 = 64
 */
System.out.println("result: " + times2.andThen(squared).apply(4)); // 64

复制代码

这两个方法,andThen表示在外面那个Function执行之后调用,compose表示在外面那个Function执行之前调用。 image.png

案例二

@Test
public void test2(){
    // 3个数相加
    Function<Integer, Function<Integer, IntFunction<Integer>>> addfun3 = x -> y -> z -> x + y + z ;
    // 7个数相加
    Function<Integer,
            Function<Integer,
                    Function<Integer,
                            Function<Integer,
                                    Function<Integer,
                                            Function<Integer, IntFunction<Integer>>>>>>>
            addfun7 = x -> y -> z -> a -> c -> b -> d -> x + y + z + a + c + b + d;
    // 1+2+3
    Integer sum = addfun3.apply(1).apply(2).apply(3);
    System.out.println(sum);
}
复制代码

通过这种方式,可以实现链式编程的累加效果 image.png

案例三


@SafeVarargs
private static <R> Function<R, R> combineFunctions(Function<R, R>... functions) {
    return Arrays.stream(functions)
            .reduce(Function::andThen)
            .orElseThrow(() -> new IllegalArgumentException("No functions to combine"));
}

@Test
public void test3() {
    Function<Integer, Integer> addfun2 = x -> x * x;
    final Integer apply = combineFunctions(addfun2, addfun2).apply(2);
    System.out.println(apply);

    String str = "1,2,3,4,5,6";
    Function<Object, Object> splitByComma = s -> ((String) s).split(",");
    Function<Object, Object> convertToInt = tokens -> Stream.of((String[]) tokens).map(Integer::valueOf).toArray(Integer[]::new);
    Function<Object, Object> findMax = ints -> Stream.of((Integer[]) ints).max(Integer::compare).get();
    Integer max = (Integer) combineFunctions(splitByComma, convertToInt, findMax).apply(str);
    System.out.println(max);
}
复制代码

如果你想有一个接受可变长度的Function参数的方法,可以使用...描述符,其中泛型<R,R>代表输入与输入类型,使用泛型是为了兼容性更高

image.png

案例四

@Test
public void test4(){
    Function<Integer, Integer> addfun2 = x -> x * x;
    final Calculator<Integer, Integer> calculator = new Calculator<>(2);
    final Integer integer = calculator.combineFunctions(addfun2, addfun2);
    System.out.println(integer);
}

public class Calculator<R,T> {
    // 被操作的属性
    private Object input;

    public Calculator(Object input) {
        this.input = input;
    }
    // 可以通过这种方式定义对象自身的行为
    @SuppressWarnings("unchecked")
    @SafeVarargs
    public final R combineFunctions(Function<T, T>... functions) {
        return (R) Arrays.stream(functions)
                .reduce(Function::andThen)
                .orElseThrow(() -> new IllegalArgumentException("No functions to combine"))
                .apply((T)input);
    }
}
复制代码

领域开发模式或多或少都听过、了解过,对象除了有自身的属性之外还可以有自身的行为,针对对象的行为方法也是可以使用函数式编程范式来定义的。

image.png

案例五

// BiConsumer<T, Integer> 两个输入参数T、Integer
 public static <T> Consumer<T> consumerWithIndex(BiConsumer<T, Integer> consumer) {
    class Obj {
        int i;
    }
    // 只会被调用一次,原因看java.lang.Iterable#forEach
    Obj obj = new Obj();
    // 返回的Consumer函数
    return t -> {
        int index = obj.i++;
        // 这里执行System.out.println("list[" + index + "]=" + item),消费指定泛型的数据。
        consumer.accept(t, index);
    };
}

@Test
public void test5(){
    val list = Arrays.asList("Hi", "I", "am", "Henry.Yao");
    // 2个元素为一组
    val partition = Lists.partition(list, 2);
    partition.forEach(LambdaUtils.consumerWithIndex((item, index) -> {
        System.out.println("list[" + index + "]=" + item);
    }));
}
复制代码

Java8的forEach()循环对象的时候,是没有办法得到对象索引下标的,针对这个情况,可以声明一个函数式方法来做到,最终书写形式类似Scala、js的forEach语法,很有用!

image.png

java.lang.Iterable#forEach

// action:是一个Consumer函数
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        /* 这里会循环调用Consumer函数,而consumerWithIndex返回的Consumer函数内容为
        t -> {
            int index = obj.i++;
            consumer.accept(t, index);
        }
        所以Obj obj = new Obj()只会被调用一次,这样就不用担心new Obj 时把 i 没有重置为0,不会发生的
        */
        consumer.accept(t, index);
    }
        action.accept(t);
    }
}
复制代码

以上只是扩展了思路,更多有趣有用的写法用法,还需要大家去挖掘去创造,如果你也有新鲜有意思的函数式方法或工具类,欢迎评论区留言分享,我们一起进步。

原创文章,作者:睿达君,如若转载,请注明出处:http://zrrd.net.cn/1431.html

发表评论

登录后才能评论
咨询电话
联系电话:0451-81320577

地址:哈尔滨市松北区中小企业总部基地13F

微信咨询
微信咨询
QQ咨询
分享本页
返回顶部