如何使用 lambda 初始化地图？

Question

我想在单个语句中声明一个完全填充的映射字段，（可能包含多个嵌套语句），如下所示：

private static final Map<Integer,Boolean> map = 
    something-returning-an-unmodifiable-fully-populated-HashMap;

匿名初始化器不会这样做，原因与调用返回新填充映射的函数不会这样做的原因相同：它们需要两个顶级语句：一个用于变量声明，一个用于方法或初始化器.

双花括号（{{ 和 }}）习语可以使用，但它创建了一个扩展 HashMap<> 的全新类，我不喜欢它所代表的开销。

Java 8 的 lambdas 是否提供了更好的方法来实现这一点？

Answer 1

如果你想在单个语句中初始化一个Map，你可以使用Collectors.toMap。

假设您想构建一个Map<Integer, Boolean> 将整数映射到调用某个函数f 的结果：

private static final Map<Integer,Boolean> MAP = 
        Collections.unmodifiableMap(IntStream.range(0, 1000)
                                             .boxed()
                                             .collect(Collectors.toMap(i -> i, i -> f(i))));

private static final boolean f(int i) {
    return Math.random() * 100 > i;
}

如果您想使用“静态”已知值对其进行初始化，例如您的答案中的示例，您可以像这样滥用 Stream API：

private static final Map<Integer, Boolean> MAP = 
       Stream.of(new Object[] { 1, false }, new Object[] { 2, true })
             .collect(Collectors.toMap(s -> (int) s[0], s -> (boolean) s[1]));

请注意，这是一个真正的滥用，我个人永远不会使用它：如果你想用已知的静态值构造一个 Map，那么使用 Streams 没有任何好处，你会更好关闭以使用静态初始化程序。

Answer 2

Google Guava's Maps class 为此提供了一些不错的实用方法。 此外，还有ImmutableMap class 及其静态方法。 看看：

    ImmutableMap.of(key1, value1, key2, value2, ...);
    Maps.uniqueIndex(values, keyExtractor);
    Maps.toMap(keys, valueMapper);

Answer 3

如果您真的想在单个语句中初始化地图，您可以编写自定义构建器并在您的项目中使用它。像这样的：

public class MapBuilder<K, V> {
    private final Map<K, V> map;

    private MapBuilder(Map<K, V> map) {
        this.map = map;
    }

    public MapBuilder<K, V> put(K key, V value) {
        if(map == null)
            throw new IllegalStateException();
        map.put(key, value);
        return this;
    }

    public MapBuilder<K, V> put(Map<? extends K, ? extends V> other) {
        if(map == null)
            throw new IllegalStateException();
        map.putAll(other);
        return this;
    }

    public Map<K, V> build() {
        Map<K, V> m = map;
        map = null;
        return Collections.unmodifiableMap(m);
    }

    public static <K, V> MapBuilder<K, V> unordered() {
        return new MapBuilder<>(new HashMap<>());
    }

    public static <K, V> MapBuilder<K, V> ordered() {
        return new MapBuilder<>(new LinkedHashMap<>());
    }

    public static <K extends Comparable<K>, V> MapBuilder<K, V> sorted() {
        return new MapBuilder<>(new TreeMap<>());
    }

    public static <K, V> MapBuilder<K, V> sorted(Comparator<K> comparator) {
        return new MapBuilder<>(new TreeMap<>(comparator));
    }
}

使用示例：

Map<Integer, Boolean> map = MapBuilder.<Integer, Boolean>unordered()
    .put(1, true).put(2, false).build();

这也适用于 Java-7。

附带说明一下，我们可能会在 Java-9 中看到类似 Map.of(1, true, 2, false) 的内容。详情请见JDK-8048330。

Answer 4

这里是如何在 Java 8 中使用 lambda 在单个语句中实现字段初始值设定项。

private static final Map<Integer,Boolean> map =
        ((Supplier<Map<Integer,Boolean>>)() -> {
            Map<Integer,Boolean> mutableMap = new HashMap<>();
            mutableMap.put( 1, false );
            mutableMap.put( 2, true );
            return Collections.unmodifiableMap( mutableMap );
        }).get();

Java 9 解决方案：

private static final Map<Integer,Boolean> map = Map.of( 1, false, 2, true );

如果您有超过 10 个条目，Map.of() 将不起作用，所以您需要这个：

private static final Map<Integer,Boolean> map = Map.ofEntries( 
        Map.entry( 1, false ), 
        Map.entry( 2, true ), 
        Map.entry( 3, false ), 
        Map.entry( 4, true ), 
        Map.entry( 5, false ), 
        Map.entry( 6, true ), 
        Map.entry( 7, false ), 
        Map.entry( 8, true ), 
        Map.entry( 9, false ), 
        Map.entry( 10, true ), 
        Map.entry( 11, false ) );