Java 8 ConcurrentHashMap初始化

Question

我正在寻找 "CLEAN & Simple" 初始化 ConcurrentHashMap 的方法。

Java 8 我有这个：-

private static final Map<String, String> myStreamedMap = Stream.of(
        new AbstractMap.SimpleImmutableEntry<>("Key1", "Value1"), 
        new AbstractMap.SimpleImmutableEntry<>("Key2", "Value2"), 
        new AbstractMap.SimpleImmutableEntry<>("Key3", "Value3"), 
        new AbstractMap.SimpleImmutableEntry<>("Key4", "Value4")).
        collect(Collectors.toMap((entry) -> entry.getKey(), (entry) -> entry.getValue()));

这提供了理想的最终结果，但我觉得

"new AbstractMap.SimpleImmutableEntry<>"

很难看清发生了什么。

有什么方法可以"hide"并保持在一行中吗？

更新

提出这个（显而易见的）解决方案

private static final Map<String, String> myStreamedMapWith = Stream.of(
        with("Key1", "Value1"), 
        with("Key2", "Value2"), 
        with("Key3", "Value3"), 
        with("Key4", "Value4")).
        collect(Collectors.toMap((entry) -> entry.getKey(), (entry) -> entry.getValue()));

private static AbstractMap.SimpleImmutableEntry<String, String> with(final String key, final String value) {
    return new AbstractMap.SimpleImmutableEntry<>(key, value);
}

Answer 1

在Java 9发布之前，没有方便的内置地图初始化方法，所以我建议看看第三方库（比如Google的Guava）：

new ConcurrentHashMap<>(com.google.common.collect.ImmutableMap.of("Key1", "Value1"));

无论如何，这里的主要问题是您正在创建 HashMap.

的实例

来自 Collectors.toMap 来源：

return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);

如果您不想使用任何外部库，一个好的方法是使用 the Builder pattern。这是一个简单的例子：

class MapBuilder<K, V> {

    private List<Map.Entry<K, V>> entries = new ArrayList<>();

    public MapBuilder<K, V> with(K key, V value) {
        entries.add(new AbstractMap.SimpleImmutableEntry<>(key, value));

        return this;
    }

    public Map<K, V> build(Supplier<Map<K, V>> mapSupplier) {
        return entries.stream().collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (k1, k2) -> k1,
                mapSupplier
                )
        );
    }

}

及其演示：

new MapBuilder().with("Key1", "Value1")
                .with("Key2", "Value2")
                .build(ConcurrentHashMap::new);

为了完全独立于实现（AbstractMap.SimpleImmutableEntry），我建议引入一个以 BiFunction<KEY, VALUE, Map.Entry<KEY, VALUE>> 入口初始化器作为参数的构造函数：

class MapBuilder<K, V> {

    private List<Map.Entry<K, V>> entries;
    private BiFunction<K, V, Map.Entry<K, V>> function;

    public MapBuilder() {
        entries = new ArrayList<>();
    }

    public MapBuilder(BiFunction<K, V, Map.Entry<K, V>> function) {
        this();
        this.function = function;
    }

    public MapBuilder<K, V> with(K key, V value) {
        entries.add(function.apply(key, value));

        return this;
    }

    public Map<K, V> build(Supplier<Map<K, V>> mapSupplier) { ... }

}

呼叫将更改为：

new MapBuilder<>(AbstractMap.SimpleImmutableEntry::new);

此时，我们可以决定分别为条目和映射选择哪种实现。

Java 8 ConcurrentHashMap初始化

Java 8 ConcurrentHashMap initialisation

java

dictionary

concurrenthashmap

java-8

java-stream