Question

我正在尝试实现一个惰性序列（意味着下一个项目仅在您调用步骤函数时计算），其中一个方法应该是“map”，它接收一个影响所有成员的函数。最优雅的方法是使用函数组合，并将新函数分配给函数变量，但由于函数不是Java中的第一类值，我不知道如何执行此操作。

我想过有一个只包含一个函数的类，作为一个“函数指针”包装器，但我不知道它是如何用于组合的。

编辑：问题与作业有关。此外，它应该能够沿着地图线处理多个合成（map（map（stepFunction（））））（在这种情况下，“map”是通过方法“map”给出的函数）。

Answer 1

欢迎来到Java及其痛苦。

interface Function<T> {
    public T eval(T argument);
}

class Lazy<T> {
    private Iterator<T> source;
    private Function<T> filter;
    Lazy(final Iterator<t> source, final Function<T> filter) {
        this.source = source;
        this.filter = filter;
    }
    public T step() {
        return filter.eval(source.next());
    }
}

Answer 2

Google Collections包含Function类型，Functions.compose(Function, Function)方法，Iterables.transform(Iterable, Function)方法等等。

如果这是作业，对你没有帮助（我真的希望每个人在他们的问题与作业有关时都会透露）。

Answer 3

在Java中，您始终使用类协议执行此操作。请参阅java.lang.Thread和规范示例的run函数。 Java中没有“函数指针”或“函数变量”。

Answer 4

FWIW，Java中的“函数指针”是一个带有单个方法的接口。您可以使用某个类实现该接口，该类提供该方法的实现，然后存储对该类对象的引用。

更改对另一个实现方法的类对象的引用，相当于将函数指针更改为指向不同的函数。

Answer 5

Java 8 添加了 java.util.function 包，这使得执行原始问题 (https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html) 成为可能：

Function<Integer, Integer> multiply = (value) -> value * 3;
Function<Integer, Integer> add      = (value) -> value + 2;

Function<Integer, Integer> addThenMultiply = multiply.compose(add);

Integer result1 = addThenMultiply.apply(3);
System.out.println(result1); // 15

仍然不是很好，但这是按照问题的要求同时使用组合和懒惰......

Answer 6

public static <T> void apply(final List<T> list, final Function<T> func)
{
    for(final T val : list)
    {
        func.perform(val);
    }
}

interface Function<T>
{
    void apply(T value);
}

class DisplayFunction<T>
    implements Function<T>
{
    public void perform(T value)
    {
        System.out.println(value);
    }
}

调用apply（list，new DisplayFunction（））;

Java中的函数组合

6 个答案: