如何将字符串转换为 lambda 表达式? [英] How to convert a string to a lambda expression?

问题描述

我想了一下，想出了一个有趣的问题，假设我们有一个配置(输入)文件:

I was thinking a bit and came up with an interesting problem, suppose we have a configuration (input) file with:

x -> x + 1
x -> x * 2
x -> x * x
x -> -x

此外，我们还有一个 Integer 列表:

And furthermore we have a list of Integers:

List<Integer> list = new ArrayList<>();
list.addAll(Arrays.toList(1, 2, 3, 4, 5));

有没有办法将 Strings(x -> x + 1 等)转换为代表的 Objects一个 lambda 表达式?然后可以用作:

Is there a way to convert the Strings (x -> x + 1, etc.) to Objects that represent a lambda expression? Which could then be used as:

Object lambda = getLambdaFromString("x -> x + 1");
if (lambda.getClass().equals(IntFunction.class) {
    list.stream().forEach()
        .mapToInt(x -> x)
        .map(x -> ((IntFunction)lambda).applyAsInt(x))
        .forEach(System.out::println);
}

我将如何编写这样的方法 getLambdaFromString?

How would I write such a method getLambdaFromString?

• 是否可以从 JDK/JRE 中重用某些内容?
• 需要我自己写吗?
• 是否可以将 Object lambda 缩小到仅捕获 lambda 的其他内容?

• Is there something I could reuse from the JDK/JRE?
• Would I need to write it all by myself?
• Is it possible to narrow down the Object lambda to something else that only captures lambdas?

推荐答案

Marko 对问题的评论是正确的.您无法从文件中读取裸 Java lambda 表达式，因为如果没有上下文提供的目标类型，则不会定义此类表达式.例如，考虑以下方法声明:

Marko's comment on the question is correct. You can't read a bare Java lambda expression out of a file, since such an expression isn't defined without a target type provided by the context. For example, consider the following method declarations:

void method1(BiFunction<String,String,String> f) { ... }
void method2(BiFunction<Integer,Integer,Integer> f) { ... }

然后在下面的代码中，

method1((x, y) -> x + y);
method2((x, y) -> x + y);

两个 lambda 表达式 (x, y) ->x + y 表示完全不同的东西.对于method1，+操作符是字符串连接，对于method2，它表示整数加法.

the two lambda expressions (x, y) -> x + y mean completely different things. For method1, the + operator is string concatenation, but for method2, it means integer addition.

这离您的问题有点远，但您可以使用动态语言读取和评估 lambda 或函数表达式.在 Java 8 中有 Nashorn JavaScript 引擎.因此，您可以使用从 Java 调用的 Nashorn 读取和评估 JavaScript 函数，而不是尝试读取 Java lambda 表达式的求值.

This is wandering a bit far afield from your question, but you can read and evaluate a lambda or function expression using a dynamic language. In Java 8 there is the Nashorn JavaScript engine. So instead of attempting to read an evaluate a Java lambda expression, you could read and evaluate a JavaScript function using Nashorn, called from Java.

以下代码采用 arg[0] 中的一个函数并将其应用于每个后续函数，并打印结果:

The following code takes a function in arg[0] and applies it to each subsequent, printing the results:

import java.util.function.Function;
import javax.script.*;

public class ScriptFunction {
    public static void main(String[] args) throws Exception {
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        @SuppressWarnings("unchecked")
        Function<Object,Object> f = (Function<Object,Object>)engine.eval(
            String.format("new java.util.function.Function(%s)", args[0]));
        for (int i = 1; i < args.length; i++) {
            System.out.println(f.apply(args[i]));
        }
    }
}

例如运行命令

java ScriptFunction 'function(x) 3 * x + 1' 17 23 47

给出结果

52.0
70.0
142.0

将函数字符串包装在 new java.util.function.Function 中是必要的，以便在 Nashorn 的 JavaScript 函数概念和 Java 的 Function 接口之间创建适配器.(可能有更好的方法，但我不知道一种方法.)将 eval 的返回值转换为 Function 会导致未经检查的强制转换警告，我认为这是不可避免的，因为这是动态类型语言 JavaScript 和静态类型 Java 之间的边界.最后，没有进行错误检查.我敢肯定，如果违反某些假设，这会以各种令人讨厌的方式爆炸，例如第一个参数实际上并不代表 JavaScript 函数.

The wrapping of the function string inside of new java.util.function.Function is necessary in order to create an adapter between Nashorn's notion of a JavaScript function and Java's Function interface. (There might be a better way, but I'm not aware of one.) The cast of the return value of eval to Function<Object,Object> results in an unchecked cast warning, which is unavoidable, I think, since this is the boundary between JavaScript, a dynamically-typed language, and Java, which is statically-typed. Finally, no error checking is done. I'm sure this will blow up in a variety of nasty ways if certain assumptions are violated, such as the first argument not actually representing a JavaScript function.

不过，如果您需要计算从文件中读取的表达式或函数，您可能会发现此技术很有用.

Still, you might find this technique useful if you have a need to evaluate expressions or functions read from a file.

这篇关于如何将字符串转换为 lambda 表达式?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！