java8 函接式口学习-Function

参考博客地址：https://blog.csdn.net/y_k_y/article/details/84632889

Function<T,R> :

抽象方法：

        R apply(T t)：传入一个参数，返回想要的结果。

默认方法：

       为了下面能更好地解释，这里先假设有两个Function实例：f1,f2

       default <V> Function<V, R> compose(Function<? super V, ? extends T> before)：f1.compose(f2).apply(arg)，表示先执行f2，然后将得到的结果传给f1执行。

       default <V> Function<T,V> andThen(Function<? super R,? extends V> after)：f1.andThen(f2).apply(arg)，表示先执行f1，然后将得到的结果传给f2执行。

静态方法：

       static <T> Function<T, T> identity()：获取到一个输入参数和返回结果一样的Function实例 

 上面的内容是来自上面链接的博客

Function提供了 compose，andThen两个方法。这几个方法的组合使用，使用顺序不同的得到的结果也不一样。

但是compose和andThen两个方法都是表示对输入的数据进行操作，只是先后顺序不一样。

有这样一个 需求，小明明妈妈让小明去买酱油，第一次给了10元，然后小明去了。

第二次妈妈也给了10元小明没有好处觉得吃亏了不去

然后妈妈总共给小明20其中的10元可以自己买吃的，

于是小明去的时候花5元买了并琪琳，然后花了10元买了酱油，回来时又花5元买了冰淇淋。

就是这样一个消费的先后的顺序

第一次消费 10-10=0

第二次消费20 -5-10-5=0

下面代码表示这样一个过程：

package com.soecode.lyf.demo.test.java8;

import org.junit.Test;

import java.util.function.Function;

/**
 * @author 魏文思
 * @date 2019/11/9$ 14:04$
 */
public class FunctionTest {

    @Test
    public void life() {
        //第一次，妈妈给小明10元去买酱油
        double tips = firstBuy(10.0, (m) -> 10.0 - getSoy().getCost());
        System.out.println("小明得到的小费：" + tips);

        //第二次，妈妈还是给小明10元买酱油，小明思考了一下，拒绝了
        System.out.println("小明将妈妈给的" + Function.identity().apply(10) + "元还了回去");

        //妈妈在了解完情况后，给了小明20元去买，小明当然很愉快去了
        double tips2 = secondBuy(20, (m) -> {
            System.out.println("买酱油前有" + m + "元");
            double v2 = m - getSoy().getCost();
            System.out.println("买完酱油后剩下" + v2 + "元");
            return v2;
        });
        System.out.println("小明剩下的小费：" + tips2);

    }

    public double firstBuy(double money, Function<Double, Double> buy) {
        return buy.apply(money);
    }

    public double secondBuy(double money, Function<Double, Double> buy) {
        //在去的路上小明先买了冰淇淋
        Function<Double, Double> beforeBuy = (m) -> {
            System.out.println("第一次买冰淇淋前有" + m + "元");
            double v1 = m - getIceCream().getCost();
            System.out.println("买完冰淇淋后剩下" + v1 + "元");
            return v1;
        };

        //回来的路上小明又买了冰淇淋
        Function<Double, Double> afterBuy = (m) -> {
            System.out.println("第二次买冰淇淋前有" + m + "元");
            double v3 = m - getIceCream().getCost();
            System.out.println("买完冰淇淋后剩下" + v3 + "元");
            return v3;
        };

        return buy.compose(beforeBuy).andThen(afterBuy).apply(money);
    }

    public Goods getSoy() {
        return new Goods("酱油", 10);
    }

    public Goods getIceCream() {
        return new Goods("冰淇淋", 5);
    }
}

执行结果如下：

一开始对这个compose andThen不是很理解，研究了一下，

这一行代码，数据源是钱，最开始的钱，apply(money)初始钱，然后去的路上花了5元，

buy.compose(beorebuy)    beforeBuy先于buy执行，拿beforeBuy的结果作为buy的源，最后再执行andThen（afterbuy）,整个顺序如下：

还是上面的总结：

      f1.compose(f2).apply(arg)，表示先执行f2，然后将得到的结果传给f1执行。

     f1.andThen(f2).apply(arg)，表示先执行f1，然后将得到的结果传给f2执行。