Java8函数类addThen默认方法

Question

我正在学习Java-8LAMBDA，我试图理解addThen默认方法在java.util.function.Function interface.As中，因为我的理解插件将首先执行第一个函数，然后它将执行第二个方法。所以我创建了一个程序如下：

//Pojo class 
  class Bike {

    public Bike(String bikeName, int price, String bikeType) {
        this.bikeName = bikeName;
        this.price = price;
        this.bikeType = bikeType;
    }

    private String bikeType;
    private String bikeName;
    private int price;

    public String getBikeType() {
        return bikeType;
    }

    @Override
    public String toString() {
        return "Bike [bikeType=" + bikeType + ", bikeName=" + bikeName + ", price=" + price + "]";
    }

    public void setBikeType(String bikeType) {
        this.bikeType = bikeType;
    }

    public String getBikeName() {
        return bikeName;
    }

    public void setBikeName(String bikeName) {
        this.bikeName = bikeName;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

}

//Main class
public class FunctionInbuildDefaultMethodsExample {

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

    static void learningAndThen() {

        Function<Bike, String> updateBikefunction = (Bike bike) -> {
            System.out.println("OldBike Name is::" + bike.getBikeName());
            bike.setBikeName("PULSOR-200CC");
            return bike.getBikeName();
        };

        Function<Bike, String> updateBikePriceFunction = (Bike bike) ->  {

            System.out.println("OldBike Price is::" + bike.getPrice());
            bike.setPrice(95000);
            return bike.getBikeName();

        };

        /*
         * First update Bike and then price
         * */
         /*Compilation error here*/
        Function<Bike,String> bikeFunction = updateBikefunction.andThen(updateBikePriceFunction);
        bikeFunction.apply( new Bike("PULSOR-125CC", 65000, "BAJAJ"));

    }
 }

我在行中得到了一个编译错误

 Function<Bike,String> bikeFunction =
updateBikefunction.andThen(updateBikePriceFunction);

作为

类型函数中的方法andThen(函数)不适用于参数(函数)

，在查看了函数接口的源代码之后，我了解到addThen默认方法正在寻找Function<String,Book>类型的实例。我的问题是，如果假设addThen默认方法执行第一个函数，然后执行作为参数传递的下一个函数，为什么函数接口的addThen默认方法是以除Function<String,Book>类型的实例的方式编写的。

Answer 1

updateBikefunction = Bike -> String
updateBikePriceFunction = Bike -> String

updateBikefunction -> updateBikePriceFunction = Bike -> String -> Bike -> String
                                                        ^^^^^^^^^^^^^^

要形成一个函数链，前面的结果应该是下一个函数的输出。这个条件被打破了。

可以将updateBikefunction更改为Function<Bike, Bike>

    Function<Bike, Bike> updateBikefunction = (Bike bike) -> {
        ...
        return bike;
    };

要编译行：

Function<Bike, String> bikeFunction = updateBikefunction.andThen(updateBikePriceFunction);

Answer 2

andThen应用于该Function的结果。因此，这是可行的，例如：

Function<Bike, String> bikeFunction = updateBikefunction
                                       .andThen(s -> s.toUpperCase());

因为结果是来自那个String的Function。

Answer 3

使用andThen方法Function作为函数之间的管道。

您的两个Function都接受一个Bike并返回一个String，这就是问题所在。

当调用[function1].andThen[function2]时，两者都具有相同的<Bike, String>参数化，[function2]期待的是Bike，但从[function1]接收String。

参见文档 (我的粗体)：

返回一个组合函数，该函数首先将该函数应用于其输入，然后将after函数应用于结果。如果对任一函数的求值引发异常，则将其中继到组合函数的调用方。