Java中的函数组合

我正在尝试实现一个延迟序列（意味着只有在调用step函数时才计算下一项），它应该具有的方法之一是“

map

”，它接收一个影响所有成员的函数。
最优雅的方法是使用函数组合，并将新函数分配给函数变量，但由于函数在Java中不是第一类值，我不知道如何做到这一点

我曾考虑过使用一个只包含函数的类作为一种“函数指针”包装器，但我不知道如何将其用于组合

编辑：问题与家庭作业有关。

---

此外，它还应该能够按照

map（map（map（stepFunction（）））

（“

map

”在这种情况下是通过方法“map”给出的函数）处理多个组合。

在Java中，您总是使用类协议来实现这一点。请参阅

java.lang.Thread

和run函数以了解规范示例。Java中没有“函数指针”或“函数变量”。

publicstaticvoidapply（最终列表，最终函数func）
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);
    }
}

{
用于（最终T值：列表）
{
执行功能（val）；
}
}
接口函数
{
无效应用（T值）；
}
类显示函数
实现功能
{
公共无效执行（T值）
{
系统输出打印项次（值）；
}
}

---

调用apply（list，newdisplayfunction（））

欢迎来到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());
    }
}

接口函数{
公共T评估（T参数）；
}
班级懒惰{
私有迭代器源；
私有函数过滤器；
惰性（最终迭代器源、最终函数过滤器）{
this.source=源；
this.filter=过滤器；
}
公共T步骤（）{
返回filter.eval（source.next（））；
}
}
有
函数
类型、
函数.组合（函数，函数）
方法、
可伸缩.变换（可伸缩，函数）
方法等等

如果这是为了家庭作业（我真的希望每个人都能透露他们的问题与家庭作业有关）。
FWIW，Java中等效的“函数指针”是一个带有单个方法的接口。使用某个类实现接口，该类提供方法的实现，然后存储对该类对象的引用

更改对另一个类对象的引用（以不同方式实现该方法）相当于更改函数指针以指向另一个函数。
Java 8添加了
Java.util.function
包，这使得可以执行原始问题所要求的操作（）：

函数乘法=（值）->值*3；
函数add=（value）->value+2；
函数addThenMultiply=multiply.compose（add）；
整数result1=addThenMultiply.apply（3）；
System.out.println（result1）；//15

尽管这不是很好，但这是在问题中所要求的构图和惰性的结合…
我不知道这对我的构图有什么帮助。也许我应该提到，它应该能够响应map（）的多个应用程序。我想要实现的行为是map（map（map（stepFunction（））））（例如）。然后让惰性扩展迭代器。。。这个想法是给你一个指向正确方向的指针，而不是写你所有的代码@EpSimon向量考虑将它变成一个流畅的界面，所以：<代码> Stand函数（）。map（函子）。map（函子）。取（5）< /代码>或随便什么，没有理由的随机下标仍然明显发生。如果您认为有问题，请礼貌地解释您的想法。这可能是因为它没有回答问题，问题是如何组合两个函数，而不仅仅是使用一个映射。此外，函数实际上并不修改其输入，而是返回一个单独的转换值。您可以将其更改为公共静态R apply（最终列表列表，最终函数func）以使其返回不同的值（或者删除R，如果返回值相同，则使用t作为返回值）。一般来说，我不会直接回答家庭作业。。。但是这个答案应该足以让事情开始了。所以当你说你想做map（map（stepFunction（）））时，这是否意味着你有一个列表列表，并且你想对该层次结构中所有子列表的每个元素调用stepFunction？我还不完全清楚你想完成什么。基本上就是这样：在任何给定的时间，我只有三样东西：阶跃函数、当前值和基值。如果Seq.map（someFunctionToMapWith）从未应用过，则当前值=基本值=步骤函数（以前的基本值）。但是，一旦将map应用于序列，每次调用seq.tail（）来更改当前值时，我都会首先更改基值，并使用给定的函数对其进行进一步修改：curr=mapFunc（stepFunc（base value））（基值也会更新）。如果多次调用map，则它应该是map（map（…map（stepFunc（base value））…）。
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