Java中使用Guava库的ImmutableMap和Function接口示例

import com.google.common.collect.ImmutableMap;

private final ImmutableMap<String, java.util.function.Function<Map<String, ? extends Object>, ? extends Object>> mapping;

这段代码是Java语言中的一段声明，使用了Google的Guava库中的`ImmutableMap`类。下面是对这段代码的详细解释：

1. `import com.google.common.collect.ImmutableMap;`：这行代码是导入语句，它告诉Java编译器从Guava库中导入`ImmutableMap`类。`ImmutableMap`是一个不可变的映射接口，意味着一旦创建了这个映射，就不能更改其内容（不能添加、删除或更改键值对）。

2. `private final ImmutableMap<String, java.util.function.Function<Map<String, ? extends Object>, ? extends Object>> mapping;`：这是对一个名为`mapping`的变量的声明，它是一个私有的（private）和最终的（final）成员变量。这意味着一旦在构造函数中初始化了这个变量，它的引用就不能再指向另一个对象，且变量的值也不能被修改。

   - `ImmutableMap<String, java.util.function.Function<Map<String, ? extends Object>, ? extends Object>>`：这是`mapping`变量的类型。它是一个`ImmutableMap`，其键（key）是`String`类型，值（value）是`Function`类型。`Function`是一个函数式接口，它接受一个输入参数并产生一个输出结果。

     - `Map<String, ? extends Object>`：这是`Function`接口的输入参数类型。它是一个映射，其键是`String`类型，值是`Object`类型或其子类型的实例。`? extends Object`是一个通配符，表示这个映射可以接受任何类型的`Object`作为值。

     - `? extends Object`：这是`Function`接口的返回值类型。它表示函数可以返回任何类型的`Object`。

举例说明：

假设我们有一个需求，需要根据给定的键值对映射来执行不同的操作。我们可以定义一个`mapping`变量，其中包含一些键（例如，操作的名称）和对应的函数，这些函数接受一个映射作为输入并返回一个结果。

import com.google.common.collect.ImmutableMap;
import java.util.Map;
import java.util.function.Function;

public class Example {
    private final ImmutableMap<String, Function<Map<String, Object>, Object>> mapping;

    public Example() {
        // 初始化mapping
        mapping = ImmutableMap.<String, Function<Map<String, Object>, Object>>builder()
                .put("add", (map) -> {
                    int a = (int) map.get("a");
                    int b = (int) map.get("b");
                    return a + b; // 返回两个整数的和
                })
                .put("multiply", (map) -> {
                    int a = (int) map.get("a");
                    int b = (int) map.get("b");
                    return a * b; // 返回两个整数的乘积
                })
                .build();
    }

    public Object executeOperation(String operation, Map<String, Object> params) {
        Function<Map<String, Object>, Object> func = mapping.get(operation);
        if (func != null) {
            return func.apply(params); // 执行对应的函数
        } else {
            throw new IllegalArgumentException("Unknown operation: " + operation);
        }
    }

    public static void main(String[] args) {
        Example example = new Example();
        Map<String, Object> params = Map.of("a", 5, "b", 10);
        System.out.println(example.executeOperation("add", params)); // 输出 15
        System.out.println(example.executeOperation("multiply", params)); // 输出 50
    }
}

在这个例子中，我们创建了一个`Example`类，它有一个`mapping`成员变量，该变量是一个不可变的映射，它将操作名称映射到对应的函数。每个函数接受一个参数映射，并根据操作名称执行特定的计算。`executeOperation`方法使用这个映射来查找并执行相应的函数。在`main`方法中，我们创建了一个`Example`对象，并调用`executeOperation`来执行加法和乘法操作。