有什么方法可以构造方法/lambda 表达式数组吗？

Question

我很好奇这些是否可能：

<something>[] methods = { method1, method2, ... }
<something>[] lambdas = { ()-><code>, ()-><code>, ... }

我认为在 C/C++ 中，您可以为同构函数类定义 typedef，然后使用 typedef 创建函数引用数组。不确定，但我认为这是可能的。这可以用 Java 完成吗？

鉴于上述定义，我想在运行时做这样的事情：

methods[i](); // or
lambdas[i]();

如果可能的话，我想包含参数。

Answer 1

当然，只需找出函数的类型（请参阅

java.util.function

包）并列出这些类型即可。

例如，您可以有一个消费者列表

List<Consumer<String>>

，它们是接受单个输入且不返回任何结果的 lambda。

Consumer<String>

的示例可能类似于

x -> System.out.println("Hello, " + x)

Answer 2

您可以声明 lambda 集合，并以通常的方式从您使用的任何集合中使用参数（视情况而定）调用每个 lambda。

例如

Runnable

的数组：

Runnable[] runables = new Runnable[] {
                            () -> System.out.println("Hello"),
                            System.out::println,
                            () -> System.out.println("World") };

runables[1].run();
for(var r : runables) {
    r.run();
}

Predicate

列表：

    List<Predicate<String>> tests = List.of(s -> "Hello".equals(s), String::isEmpty);

    System.out.println(tests.get(0).test("Hello"));
    System.out.println(tests.get(0).test("World"));
    System.out.println(tests.get(1).test(""));
    System.out.println(tests.get(1).test("World"));

Answer 3

如果您想要存储方法列表，也许作为命令菜单，您可以创建一个接口（包含所有必需的方法）和一个基类来实现该接口。

然后让几个子类扩展基类，您可以将所有子类的实例存储在一个数组中作为要调用的命令列表。使用基类将确保每个实例都有要调用的默认方法，即使没有被子类覆盖。

interface CommandAPI {
    public void op();
}

class Command implements CommandAPI {
    public void op() {}   // default method
}

class A extends Command {
    @Override
    public void op() {}
}

class B extends Command {
    @Override
    public void op() {}
}

public class App {
    public static void main(String[] args) {
        Command[] list = { new A(), new B() };
        //...
        list[0].op();
        list[1].op();
    }
}

甚至可以支持命名参数化命令。

 interface CommandAPI {
    public void cmd();
 }
    
 class Command implements CommandAPI {
    public void cmd() {}   // default method
 }
    
 class A extends Command {
    public int param;
    @Override
    public void cmd() { /* do something with param */ }
 }
    
 class B extends Command {
    public int param1;
    public String param2;
    @Override
    public void cmd() {  /* do something with param 1 and 2 */ }
 }
    
 public class FuncPtr {
    public static void main(String[] args) {
        Command[] list = { new A(), new B() };
        //...
              
        if(list[0] instanceof A) {
            ( (A) list[0] ).param = 1;
        }
        list[0].cmd();

        if(list[1] instanceof B) {
            ( (B) list[1] ).param1 = 100;
            ( (B) list[1] ).param2 = "Hello";
        }
        list[1].cmd();
        //...
    }
}