Java HashMap生成器

Guava为我们提供了Java类型的优秀工厂方法，例如

Maps.newHashMap（）

但是也有java映射的构建器吗

HashMap<String,Integer> m = Maps.BuildHashMap.
    put("a",1).
    put("b",2).
    build();

HashMap m=Maps.BuildHashMap。
放入（“a”，1）。
放入（b），2）。
build（）；

您可以使用：

HashMap<String,Integer> m = Maps.newHashMap(
    ImmutableMap.of("a",1,"b",2)
);

HashMap m=Maps.newHashMap(
不可变地图（a，1，b，2）
);

---

它没有那么优雅和可读性，但确实有用。

不太像一个构建器，但使用了一个初始值设定项：

Map<String, String> map = new HashMap<String, String>() {{
    put("a", "1");
    put("b", "2");
}};

Map Map=newhashmap（）{{
将（“a”、“1”）；
认沽权（“b”、“2”）；
}};

HashMaps没有这样的功能，但您可以使用生成器创建一个不可变映射：

final Map<String, Integer> m = ImmutableMap.<String, Integer>builder().
      put("a", 1).
      put("b", 2).
      build();

final Map m=ImmutableMap.builder（）。
放入（“a”，1）。
放入（b），2）。
build（）；

如果您需要一个可变映射，您可以将其提供给HashMap构造函数

final Map<String, Integer> m = Maps.newHashMap(
    ImmutableMap.<String, Integer>builder().
        put("a", 1).
        put("b", 2).
        build());

final Map m=Maps.newHashMap(
ImmutableMap.builder（）。
放入（“a”，1）。
放入（b），2）。
build（））；

HashMap

是可变的；不需要建筑工人

Map<String, Integer> map = Maps.newHashMap();
map.put("a", 1);
map.put("b", 2);

Map Map=Maps.newHashMap（）；
地图放置（“a”，1）；
地图放置（“b”，2）；

编写一个简单的地图生成器非常简单：

public class Maps {

    public static <Q,W> MapWrapper<Q,W> map(Q q, W w) {
        return new MapWrapper<Q, W>(q, w);
    }

    public static final class MapWrapper<Q,W> {
        private final HashMap<Q,W> map;
        public MapWrapper(Q q, W w) {
            map = new HashMap<Q, W>();
            map.put(q, w);
        }
        public MapWrapper<Q,W> map(Q q, W w) {
            map.put(q, w);
            return this;
        }
        public Map<Q,W> getMap() {
            return map;
        }
    }

    public static void main(String[] args) {
        Map<String, Integer> map = Maps.map("one", 1).map("two", 2).map("three", 3).getMap();
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}

公共类映射{
公共静态MapWrapper映射（Q，W）{
返回新的MapWrapper（q，w）；
}
公共静态最终类映射包装器{
私有最终哈希映射；
公共映射包装器（Q，W）{
map=新的HashMap（）；
map.put（q，w）；
}
公共地图包装器地图（Q，W）{
map.put（q，w）；
归还这个；
}
公共地图getMap（）{
返回图；
}
}
公共静态void main（字符串[]args）{
Map-Map=Maps.Map（“一”，1）.Map（“二”，2）.Map（“三”，3.getMap（）；
对于（Map.Entry:Map.entrySet（））{
System.out.println（entry.getKey（）+“=”+entry.getValue（））；
}
}
}

这与公认的答案相似，但在我看来，有点简洁：

ImmutableMap.of("key1", val1, "key2", val2, "key3", val3);

---

上述方法有几种变体，它们非常适合制作静态、不变、不变的地图。

我不久前也有类似的要求。这与番石榴无关，但你可以做类似的事情，使用fluent构建器清晰地构建

Map

创建扩展映射的基类

public class FluentHashMap<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = 4857340227048063855L;

    public FluentHashMap() {}

    public FluentHashMap<K, V> delete(Object key) {
        this.remove(key);
        return this;
    }
}

---

这是我一直想要的，尤其是在设置测试夹具时。最后，我决定自己编写一个简单的fluent builder，可以构建任何地图实现-

/**
*@param mapClass任意{@link Map}实现类型。e、 例如，HashMap.class
*/
公共静态MapBuilder生成器（@SuppressWarnings（“rawtypes”）类这里是一个非常简单的类

public class FluentHashMap<K, V> extends java.util.HashMap<K, V> {
  public FluentHashMap<K, V> with(K key, V value) {
    put(key, value);
    return this;
  }

  public static <K, V> FluentHashMap<K, V> map(K key, V value) {
    return new FluentHashMap<K, V>().with(key, value);
  }
}

公共类FluentHashMap扩展了java.util.HashMap{
带有（K键，V值）的公共FluentHashMap{
put（键、值）；
归还这个；
}
公共静态流量图（K键，V值）{
使用（键，值）返回新的FluentHashMap（）；
}
}

然后

导入静态FluentHashMap.map；
HashMap m=map（“a”，1）。带（“b”，2）；

看
这是我写的一篇

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

public class MapBuilder<K, V> {

    private final Map<K, V> map;

    /**
     * Create a HashMap builder
     */
    public MapBuilder() {
        map = new HashMap<>();
    }

    /**
     * Create a HashMap builder
     * @param initialCapacity
     */
    public MapBuilder(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

    /**
     * Create a Map builder
     * @param mapFactory
     */
    public MapBuilder(Supplier<Map<K, V>> mapFactory) {
        map = mapFactory.get();
    }

    public MapBuilder<K, V> put(K key, V value) {
        map.put(key, value);
        return this;
    }

    public Map<K, V> build() {
        return map;
    }

    /**
     * Returns an unmodifiable Map. Strictly speaking, the Map is not immutable because any code with a reference to
     * the builder could mutate it.
     *
     * @return
     */
    public Map<K, V> buildUnmodifiable() {
        return Collections.unmodifiableMap(map);
    }
}

import java.util.Collections；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.function.Supplier；
公共类映射生成器{
私人最终地图；
/**
*创建HashMap生成器
*/
公共地图生成器（）{
map=新的HashMap（）；
}
/**
*创建HashMap生成器
*@param初始容量
*/
公共地图生成器（int initialCapacity）{
map=新HashMap（初始容量）；
}
/**
*创建地图生成器
*@param映射工厂
*/
公共地图生成器（供应商地图工厂）{
map=mapFactory.get（）；
}
公共MapBuilder放置（K键，V值）{
map.put（键、值）；
归还这个；
}
公共地图构建（）{
返回图；
}
/**
*返回一个不可修改的映射。严格来说，映射不是不可变的，因为任何引用
*建筑商可以对它进行变异。
*
*@返回
*/
公共地图构建不可修改（）{
返回集合。不可修改映射（map）；
}
}

您可以这样使用它：

ValueMap map = new ValueMap()
      .withValue("key 1", "value 1")
      .withValue("key 2", "value 2")
      .withValue("key 3", "value 3")

Map<String, Object> map = new MapBuilder<String, Object>(LinkedHashMap::new)
    .put("event_type", newEvent.getType())
    .put("app_package_name", newEvent.getPackageName())
    .put("activity", newEvent.getActivity())
    .build();

Map Map=newmapbuilder（LinkedHashMap:：new）
.put（“事件类型”，newEvent.getType（））
.put（“应用程序包名称”，newEvent.getPackageName（））
.put（“活动”，newEvent.getActivity（））
.build（）；
因为Java 9接口包含：


地图（k1、v1、k2、v2、…）
入口地图（地图入口（k1，v1），地图入口（k2，v2），…）

这些工厂方法的局限性在于：


无法将
null
s作为键和/或值保存（如果需要存储null，请查看其他答案）
生成不变的映射

如果我们需要可变映射（比如HashMap），我们可以使用它的复制构造函数，让它复制通过（…）的
map.of创建的映射的内容

Map-Map=新的HashMap（映射为（1，“a”，2，“b”，3，“c”）；
使用java 8:

import static your.package.name.MapUtil.*;

import java.util.Map;

Map<String, Object> map = ofEntries(
        entry("id", 1),
        entry("description", "xyz"),
        entry("value", 1.05),
        entry("enable", true)
    );

这是Java-9
Map.ofEntries（Map.entry（k1，v1）、Map.entry（k2，v2）的一种方法……）

公共类MapUtil{
导入静态java.util.stream.Collectors.toMap；
导入java.util.AbstractMap.SimpleEntry；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.stream.stream；
私有MapUtil（）{}
@安全变量
入口的公共静态映射（SimpleEntry…值）{
返回Stream.of（values）.collect（toMap（Entry:：getKey，Entry:：getValue））；
}
公共静态SimpleEntry项（字符串键、对象值）{
返回新的SimpleEntry（键、值）；
}
}

如何使用：

import static your.package.name.MapUtil.*;

import java.util.Map;

Map<String, Object> map = ofEntries(
        entry("id", 1),
        entry("description", "xyz"),
        entry("value", 1.05),
        entry("enable", true)
    );

导入静态的.package.name.MapUtil.*；
导入java.util.Map；
Map=of入口(
条目（“id”，1），
条目（“说明”、“xyz”），
条目（“值”，1.05），
输入（“启用”，真）
);
Map<String, Object> map = new MapBuilder<String, Object>(LinkedHashMap::new)
    .put("event_type", newEvent.getType())
    .put("app_package_name", newEvent.getPackageName())
    .put("activity", newEvent.getActivity())
    .build();

Map<Integer, String> map = new HashMap<>( Map.of(1,"a", 2,"b", 3,"c") );

public class MapUtil {
    import static java.util.stream.Collectors.toMap;

    import java.util.AbstractMap.SimpleEntry;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.stream.Stream;

    private MapUtil() {}

    @SafeVarargs
    public static Map<String, Object> ofEntries(SimpleEntry<String, Object>... values) {
        return Stream.of(values).collect(toMap(Entry::getKey, Entry::getValue));
    }

    public static SimpleEntry<String, Object> entry(String key, Object value) {
        return new SimpleEntry<String, Object>(key, value);
    }
}

import static your.package.name.MapUtil.*;

import java.util.Map;

Map<String, Object> map = ofEntries(
        entry("id", 1),
        entry("description", "xyz"),
        entry("value", 1.05),
        entry("enable", true)
    );

Map<String, Integer> map = Maps.mutable.<String, Integer>empty()
        .withKeyValue("a", 1)
        .withKeyValue("b", 2);

Assert.assertEquals(Maps.mutable.with("a", 1, "b", 2), map);

Map<String, Object> value = U.objectBuilder()
        .add("firstName", "John")
        .add("lastName", "Smith")
        .add("age", 25)
        .add("address", U.arrayBuilder()
            .add(U.objectBuilder()
                .add("streetAddress", "21 2nd Street")
                .add("city", "New York")
                .add("state", "NY")
                .add("postalCode", "10021")))
        .add("phoneNumber", U.arrayBuilder()
            .add(U.objectBuilder()
                .add("type", "home")
                .add("number", "212 555-1234"))
            .add(U.objectBuilder()
                .add("type", "fax")
                .add("number", "646 555-4567")))
        .build();
    // {firstName=John, lastName=Smith, age=25, address=[{streetAddress=21 2nd Street,
    // city=New York, state=NY, postalCode=10021}], phoneNumber=[{type=home, number=212 555-1234},
    // {type=fax, number=646 555-4567}]}