Java 8：带有可变参数的 Lambda

Question

我正在寻找一种调用多个参数方法但使用lambda 构造的方法。在文档中说，lambda 只有在可以映射到功能接口时才可用。

我想做这样的事情：

test((arg0, arg1) -> me.call(arg0, arg1));
test((arg0, arg1, arg2) -> me.call(arg0, arg1, arg2));
...

有没有什么方法可以优雅地做到这一点，而无需定义 10 个接口，每个参数计数一个？

更新

我使用从非方法接口扩展而来的多个接口，并且重载了该方法。

两个参数的示例：

interface Invoker {}
interface Invoker2 extends Invoker { void invoke(Object arg0, Object arg1);}
void test(Invoker2 invoker, Object ... arguments) {
    test((Invoker)invoker, Object ... arguments);
}

void test(Invoker invoker, Object ... arguments) {
    //Use Reflection or whatever to access the provided invoker
}

我希望有可能用一个解决方案替换 10 个调用程序接口和 10 个重载方法。

我有一个合理的用例，请不要问诸如“你为什么要做这样的事情？”之类的问题。和“你要解决的问题是什么？”或类似的东西。只要知道我已经考虑过了，这是我正在尝试解决的合理问题。

很抱歉添加混淆调用它，但它实际上是在我当前的用例（测试构造函数合同）中调用的。

基本上，如上所述，请考虑一种方法，该方法适用于lambda 中不同数量的属性。

Answer 1

在Java 中你需要使用这样的数组。

test((Object[] args) -> me.call(args));

如果call 采用数组变量args，这将起作用。如果没有，您可以使用反射来进行调用。

Answer 2

我目前使用的最终解决方案是定义接口的层次结构（如问题中所述）并使用默认方法来避免失败。伪代码如下：

interface VarArgsRunnable {
     default void run(Object ... arguments) {
          throw new UnsupportedOperationException("not possible");
     }
     default int getNumberOfArguments() {
          throw new UnsupportedOperationException("unknown");
     }
}

以及四个参数的接口，例如：

@FunctionalInterface
interface VarArgsRunnable4 extends VarArgsRunnable {
     @Override
     default void run(Object ... arguments) {
          assert(arguments.length == 4);
          run(arguments[0], arguments[1], arguments[2], arguments[3]);
     }

     void run(Object arg0, Object arg1, Object arg2, Object arg3, Object arg4);

     @Override
     default int getNumberOfArguments() {
          return 4;
     }
}

定义了从 VarArgsRunnable0 到 VarArgsRunnable10 的 11 个接口，重载一个方法变得非常容易。

public void myMethod(VarArgsRunnable runnable, Object ... arguments) {
     runnable.run(arguments);
}

由于 Java 无法通过使用 instance.myMethod((index, value) -> doSomething(to(index), to(value)), 10, "value") 之类的东西找到 VarArgsRunnable 的正确扩展功能接口来组成 Lambda，因此需要使用正确的接口重载方法。

public void myMethod(VarArgsRunnable2 runnable, Object arg0, Object arg1) {
    myMethod((VarArgsRunnable)runnable, combine(arg0, arg1));
}

private static Object [] combine(Object ... values) {
    return values;
}

由于这需要使用 to(...) 将 Object 转换为任何适当的类型，因此可以使用泛型进行参数化以避免这种用法。

to-方法如下所示： 公共静态 T 到（对象值）{ 返回（T）值； //禁止这个警告 }

这个例子很蹩脚，但我用它来调用一个具有多个参数的方法，这些参数是所有潜在组合的排列（用于测试目的），例如：

run((index, value) -> doTheTestSequence(index, value), values(10, 11, 12), values("A", "B", "C"));

所以这条小线运行了 6 次调用。所以你看到这是一个简洁的助手，能够在一行中测试多个东西，而不是定义更多或在 TestNG 中使用多种方法等等......。

PS：不需要使用反射是一件好事，因为它不会失败并且非常节省参数计数。

Answer 3

我为自己的用例所做的是定义一个辅助方法，它接受可变参数，然后调用 lambda。我的目标是 1) 能够在方法中定义一个函数以保持简洁和范围（即 lambda）和 2) 对该 lambda 的调用非常简洁。最初的发布者可能有类似的目标，因为他在上面的一个 cmets 中提到，希望避免为每个调用编写 Object[] {...} 的冗长。也许这对其他人有用。

步骤#1：定义辅助方法：

public static void accept(Consumer<Object[]> invokeMe, Object... args) {
    invokeMe.accept(args);
}

第 2 步：定义一个可以使用不同数量参数的 lambda：

Consumer<Object[]> add = args -> {
    int sum = 0;
    for (Object arg : args)
        sum += (int) arg;
    System.out.println(sum);
};

第 3 步：多次调用 lambda - 这种简洁性就是我想要语法糖的原因：

accept(add, 1);
accept(add, 1, 2);
accept(add, 1, 2, 3);
accept(add, 1, 2, 3, 4);
accept(add, 1, 2, 3, 4, 5);
accept(add, 1, 2, 3, 4, 5, 6);

Answer 4

我很好奇用于可变数量参数的 lambda 是否可以工作。确实如此。见：

public class Example {
    public interface Action<T> {
        public void accept(T... ts);
    }

    public static void main(String args[]) {
        // Action<String> a = (String... x) -> { also works
        Action<String> a = (x) -> {
            for(String s : x) {
                System.out.println(s);
            }
        };

        a.accept("Hello", "World");
    }
}

我知道问题已得到解答。这主要是为那些好奇并看到这篇文章的人准备的。

Answer 5

我相信下面的代码应该可以适应你想要的：

public class Main {
    interface Invoker {
      void invoke(Object ... args);
    }

    public static void main(String[] strs) {
        Invoker printer = new Invoker() {
            public void invoke(Object ... args){
                for (Object arg: args) {
                    System.out.println(arg);
                }
            }
        };

        printer.invoke("I", "am", "printing");
        invokeInvoker(printer, "Also", "printing");
        applyWithStillAndPrinting(printer);
        applyWithStillAndPrinting((Object ... args) -> System.out.println("Not done"));
        applyWithStillAndPrinting(printer::invoke);
    }

    public static void invokeInvoker(Invoker invoker, Object ... args) {
        invoker.invoke(args);
    }

    public static void applyWithStillAndPrinting(Invoker invoker) {
        invoker.invoke("Still", "Printing"); 
    }
}

请注意，您不必创建 lambda 并将其传递给 me.call，因为您已经拥有对该方法的引用。你可以打电话给test(me::call)，就像我打电话给applyWithStillAndPrinting(printer::invoke)一样。

Answer 6

是的

您不需要重载方法或多个接口。可以使用带有可变参数列表方法的单个功能接口来完成。

但是，由于 Java 可变参数是使用隐式数组实现的，因此您的 lambda 将采用单个通用数组参数，并且必须处理从数组中解包参数。

如果您的函数的参数并非全部属于同一个类，那么您还必须处理类型转换，这会带来所有固有的危险。

示例

package example;
import java.util.Arrays;
import java.util.List;

public class Main {
    @FunctionalInterface
    public interface Invoker<T, R> {
        R invoke(T... args);
    }

    @SafeVarargs
    public static <T, R> void test(Invoker<T, R> invoker, T...args) {
        System.out.println("Test result: " + invoker.invoke(args));
    }

    public static Double divide(Integer a, Integer b) {
        return a / (double)b;
    }

    public static String heterogeneousFunc(Double a, Boolean b, List<String> c) {
        return a.toString() + ", " + b.hashCode() + ", " + c.size();
    }

    public static void main(String[] args) {
        Invoker<Integer, Double> divideInvoker = argArray -> Main.divide(
                argArray[0], argArray[1]
        );

        test(divideInvoker, 22, 7);

        Invoker<Object, String> weirdInvoker = argArray -> heterogeneousFunc(
                (Double) argArray[0], (Boolean) argArray[1], (List<String>) argArray[2]
        );

        test(weirdInvoker, 1.23456d, Boolean.TRUE, Arrays.asList("a", "b", "c", "d"));

        test(weirdInvoker, Boolean.FALSE, Arrays.asList(1, 2, 3), 9.999999d);
    }
}

输出：

Test result: 3.142857142857143
Test result: 1.23456, 1231, 4
Exception in thread "main" java.lang.ClassCastException: class java.lang.Boolean cannot be cast to class java.lang.Double
    at example.Main.lambda$main$1(Main.java:27)
    at example.Main.test(Main.java:13)
    at example.Main.main(Main.java:32)