在Java8中，如何为每个元素流调用不同的函数？

我想在Java8中采用类似的方法。我是pythonist，这里是我需要做的一个例子，但是用Python

def function1(x):
    return x * 1

def function2(x):
    return x * 2

def function3(x):
    return x * 3

status = {"BOOK": function1,
          "ISSUING": function2,
          "RETRYING": function3}

for k, v in status.items():
    print("status {0} call function {1}, \
     result: {2}".format(k, v, v(2)))

在Java8中如何实现相同的效果或方法？求你了

在上面的@Guilheme help me[解决]之后，我得到了类似的方法：

import java.util.HashMap;
import java.util.Map;

public class ExampleCallDifferentFunction {

    public static int multiply1(int x) {
        return x * 1;
    }

    public static int multiply2(int x) {
        return x * 2;
    }

    public static int multiply3(int x) {
        return x * 3;
    }

    interface Function {
        int function(int x);
    }

    private static Map<String, Function> createMap() {
        Map<String,Function> myMap = new HashMap<String,Function>();
        myMap.put("BOOK", (x) -> multiply1(x));
        myMap.put("ISSUING", (x) -> multiply2(x));
        myMap.put("RETRYING",(x) -> multiply3(x));
        return myMap;
    }

    public static void main(String[] args) {

        Map<String, Function> status = createMap();
        int x = 2;

        for (Map.Entry<String, Function> entry : status.entrySet()) {
            Function f = entry.getValue();
            System.out.printf("status %s call %s result: %d\n", entry.getKey(), entry.getValue(), f.function(2));
        }
    }
}

import java.util.HashMap；
导入java.util.Map；
公共类示例CallDifferentitFunction{
公共静态整数倍1（整数x）{
返回x*1；
}
公共静态整数倍2（整数x）{
返回x*2；
}
公共静态整数倍数3（整数x）{
返回x*3；
}
接口函数{
int函数（intx）；
}
私有静态映射createMap（）{
Map myMap=newhashmap（）；
myMap.put（“BOOK”，（x）->倍数1（x））；
myMap.put（“发行”，（x）->倍数2（x））；
put（“重试”，（x）->multiply3（x））；
返回myMap；
}
公共静态void main（字符串[]args）{
映射状态=createMap（）；
int x=2；
对于（Map.Entry:status.entrySet（））{
函数f=entry.getValue（）；
System.out.printf（“状态%s调用%s结果：%d\n”，entry.getKey（），entry.getValue（），f.function（2））；
}
}
}

以下是代码：

import java.util.HashMap;
import java.util.Map;

public class Main {

    interface Function {
        int function(int x);
    }

    public static void main(String[] args) {

        Map<String, Function> status = new HashMap<>();

        status.put("BOOK", (x) -> x);
        status.put("ISSUING", (x) -> x * 2);
        status.put("RETRYING", (x) -> x * 3);

        for (Map.Entry<String, Function> entry : status.entrySet()) {
            Function f = entry.getValue();
            System.out.printf("status %s call %s result: %d\n", entry.getKey(), entry.getValue(), f.function(2));
        }

    }
}

import java.util.HashMap；
导入java.util.Map；
公共班机{
接口函数{
int函数（intx）；
}
公共静态void main（字符串[]args）{
映射状态=新建HashMap（）；
状态.put（“BOOK”，（x）->x）；
状态。投入（“发行”，（x）->x*2）；
状态.put（“重试”，（x）->x*3）；
对于（Map.Entry:status.entrySet（））{
函数f=entry.getValue（）；
System.out.printf（“状态%s调用%s结果：%d\n”，entry.getKey（），entry.getValue（），f.function（2））；
}
}
}

虽然您可以使用地图，但感觉使用

枚举将是一种更自然的解决方案：

enum Status {
    BOOK(x -> x * 1),
    ISSUING(x -> x * 2),
    RETRYING(x -> x * 3);

    private final IntUnaryOperator operator;

    private Status(IntUnaryOperator operator) {
        this.operator = operator;
    }

    public int apply(int argument) {
        return operator.apply(argument);
    }
}

然后可以使用
valueOf
从字符串转换（本例使用
Optional
捕获非法值情况）：

或者，如果要应用每个值：

for (Status status: Status.values()) {
    System.out.println(status + ":" + status.apply(2));
}

一般来说，如果你知道编译时的对象集，那么就考虑一个<代码>枚举< /代码>。很明显，对于代码的读者来说，这是一个在运行时不会更改的固定列表

有趣的是，在Java的openjdk实现中，
valueOf
实际上在内部使用了一个从
String
到常量的映射，所以这一点效率并不低。
那么您在Java中尝试的代码是什么呢？我将发布一些代码，很快在Java 8中使用分部函数，请稍等。为什么您认为可以提供一个原始函数作为参数？因为他正在按名称映射函数原始声明有什么问题？我的错，您在这里声明了自己的
函数
，我还以为是
java.util.function
。不过你不需要，已经有了
IntFunction
或者
Function
，我知道，但这是一个教学代码，不是生产代码。他不想学着用他不懂的语言做事。我在解释怎么做。谢谢，但这只是一个方法的例子，我真正的（生产）问题是，我有更复杂的方法，有4个参数，具有相同的签名，但做不同的事情。所以，我不会使用运算符，因为@guilherme在我的specify案例中是一个更好的方法。@anderaujo我使用运算符也只是一个例子。它可以与任何接口一起工作。重要的问题不是方法的签名，而是方法的实现数量是固定的还是可变的。好吧，但是假设方法参数不是整数或字符串，而是对象或对象列表，您的方法更依赖于我的示例，但也非常好！就那样！谢谢。@AndreAraujo实际上，这种方法完全不依赖于细节——它同样适用于任何参数，包括对象或对象列表。
for (Status status: Status.values()) {
    System.out.println(status + ":" + status.apply(2));
}