5

我正在尝试实现一个惰性序列（意味着仅在调用 step 函数时才计算下一项），它应该具有的方法之一是“ map”，它接收一个影响所有成员的函数。
最优雅的方法是使用函数组合，并将新函数分配给函数变量，但由于函数不是 Java 中的第一类值，我不知道该怎么做。

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

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

4

6 回答 6

6

欢迎来到 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());
    }
}
于 2009-11-19T21:03:08.583 回答
5

Google Collections有Function类型、Functions.compose(Function, Function)方法、Iterables.transform(Iterable, Function)方法等等。

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

于 2009-11-19T21:18:11.363 回答
1

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

于 2009-11-19T20:59:00.153 回答
0

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

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

于 2009-11-19T21:38:59.290 回答
0

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

仍然不是真的超级好，但这是问题中要求的同时使用组合和懒惰......

于 2021-03-05T13:44:56.743 回答
-1 
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());

于 2009-11-19T21:01:24.250 回答