多功能组合

Question

今天我遇到了以下 Java 作业，但我不知道如何通过类型擦除。

任务是创建一个通用 InputConverter 类，该类接受 T 类型的输入并使用作为方法参数接收的多个函数链对其进行转换。它必须支持以下符号：

Function<String, List<String>> lambda1 = ...;
Function<List<String>, String> lambda2 = ...;
Function<String, Integer> lambda3 = ...;

String input = ...;

List<String> res1 = new InputConverter(input).convertBy(lambda1);

Integer res2 = new InputConverter(input).convertBy(lambda1, lambda2, lambda3);

这是我想出的：

import java.util.Arrays;
import java.util.function.Function;

public class InputConverter<T> {
    private final T input;

    public InputConverter(T input) {
        this.input = input;
    }

    public <B> B convertBy(Function<T, ?> first, Function<?, ?>... functions) {
        var res = first.apply(input);

        Function<?, B> composed = Arrays.stream(functions)
            .reduce(Function::andThen)
            .orElse(Function.identity());

        return composed.apply(res);
    }

}

这当然行不通，因为我找不到确定最后一个函数的返回类型的方法。

注意事项：

• InputConverter 应该只定义一个convertBy 方法，因此方法重载不是一种选择。
• 此方法应返回链中最后一个函数的结果，无需显式强制转换。

Answer 1

因此，根据任务的作者，正确的解决方案是：

import java.util.Arrays;
import java.util.function.Function;

public class InputConverter<T> {
    private final T input;

    public InputConverter(T input) {
        this.input = input;
    }

    public <B> B convertBy(Function<T, ?> first, Function... functions) {
        var res = first.apply(input);

        Function<Object, B> composed = Arrays.stream(functions)
            .reduce(Function::andThen)
            .orElse(Function.identity());

        return composed.apply(res);
    }

}

这对我来说根本不满意。它允许使用可变参数，但使用原始的、未参数化的 Function 毫无意义。 Nikolas Charalambidis' answer 是一个更好的解决方案，因为我们保留了返回类型信息和安全性。

Answer 2

问题

您需要为每个数量的预期函数链接泛型，并将泛型参数链接到下面的 sn-p 中，其中包含五个函数：

public <D> E convertBy(
    Function<T, A> first, Function<A, B> second, Function<B, C> third, 
    Function<C, D> fourth, Function<D, E> fifth) {
    ...
}

但是，对于未知数量的参数（可变参数），这是不可能的。没有像“vargenerics”这样的东西，它会像上面那样动态创建和链接泛型参数。

---

解决方案

您可以将InputConverter 视为一个builder，而不是在每个convertBy 调用中返回self，最后打包一个结果。这种递归行为允许无限数量的调用。试试看：

public static class InputConverter<T> {

    private final T data;

    public InputConverter(T data) {
        this.data = data;
    }

    public <U> InputConverter<U> convertBy(Function<T, U> function) {
        return new InputConverter<>(function.apply(data));
    }

    public T pack() {
        return data;
    }
}

很整洁，不是吗？让我们看看最小样本的用法：

// let lambda1 split String by characters and create a List
Function<String, List<String>> lambda1 = str -> Arrays.stream(str.split(""))
                                                      .collect(Collectors.toList());
// let lambda2 get the first item
Function<List<String>, String> lambda2 = list -> list.get(0);

// let lambda3 parse a String into the Integer
Function<String, Integer> lambda3 = Integer::parseInt;

String input = "123";                                   // out sample numeric input

List<String> res1 = new InputConverter<String>(input)   // don't forget the generics
    .convertBy(lambda1)
    .pack();

Integer res2 = new InputConverter<String>(input)
    .convertBy(lambda1)
    .convertBy(lambda2)
    .convertBy(lambda3)
    .pack();

System.out.println(res1);                               // [1, 2, 3]
System.out.println(res2);                               // 1