MapJavaでstaticをどのように初期化しますか？

方法1：静的初期化子
方法2：インスタンス初期化子（匿名サブクラス）またはその他のメソッド？

それぞれの長所と短所は何ですか？

2つの方法を示す例を次に示します。

import java.util.HashMap;
import java.util.Map;

public class Test {
    private static final Map<Integer, String> myMap = new HashMap<>();
    static {
        myMap.put(1, "one");
        myMap.put(2, "two");
    }

    private static final Map<Integer, String> myMap2 = new HashMap<>(){
        {
            put(1, "one");
            put(2, "two");
        }
    };
}

この場合、インスタンスのイニシャライザは単に構文上の砂糖ですよね？初期化するためだけに追加の匿名クラスが必要な理由はわかりません。そして、作成されるクラスがfinalの場合は機能しません。

静的イニシャライザを使用して不変マップを作成することもできます：

public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);
    }
}

静的で不変のマップを初期化するGuavaの方法が好きです。

static final Map<Integer, String> MY_MAP = ImmutableMap.of(
    1, "one",
    2, "two"
);

ご覧のとおり、非常に簡潔です（の便利なファクトリメソッドによりImmutableMap）。

マップに5つを超えるエントリを含める場合は、を使用できなくなりますImmutableMap.of()。代わりに、ImmutableMap.builder()次の行を試してください。

static final Map<Integer, String> MY_MAP = ImmutableMap.<Integer, String>builder()
    .put(1, "one")
    .put(2, "two")
    // ... 
    .put(15, "fifteen")
    .build();

Guavaの不変コレクションユーティリティの利点の詳細については、「Guava User Guide」の「Immutable Collections Explained」を参照してください。

グアバ（のサブセット）は、以前はGoogleコレクションと呼ばれていました。このライブラリをJavaプロジェクトでまだ使用していない場合は、ぜひお試しください。Guavaは、SOの仲間のユーザーが同意するように、Javaで最も人気があり便利な無料のサードパーティライブラリの1つになりました。（これに慣れていない場合は、そのリンクの背後にいくつかの優れた学習リソースがあります。）

アップデート（2015）：Java 8に関しては、他の方法よりもずっとクリーンなので、私はまだGuavaアプローチを使用します。Guavaに依存したくない場合は、単純な古いinitメソッドを検討してください。2次元配列とストリームAPIを使用したハックは、私に尋ねるとかなり醜く、キーと値が同じ型ではない（Map<Integer, String>質問のように）マップを作成する必要がある場合は醜くなります。

グアバの将来については一般的に、Java 8に関して、ルイスワッサーマンは2014年にこれを述べ、2016年に[ 更新 ] グアバ21がJava 8を必要とし、適切にサポートすることが発表されました。

更新（2016）：Tagir Valeevが指摘しているように、Java 9はコレクションに便利なファクトリーメソッドを追加することにより、純粋なJDKのみを使用してこれを最終的にクリーンにします。

static final Map<Integer, String> MY_MAP = Map.of(
    1, "one", 
    2, "two"
);

私は使うだろう：

public class Test {
    private static final Map<Integer, String> MY_MAP = createMap();

    private static Map<Integer, String> createMap() {
        Map<Integer, String> result = new HashMap<>();
        result.put(1, "one");
        result.put(2, "two");
        return Collections.unmodifiableMap(result);
    }
}

1. 個人的に悪いスタイルだと私が考える匿名クラスを避け、
2. マップの作成をより明確にします
3. マップを変更できなくなります
4. MY_MAPは定数なので、定数のように名前を付けます

Java 5は、このよりコンパクトな構文を提供します。

static final Map<String , String> FLAVORS = new HashMap<String , String>() {{
    put("Up",    "Down");
    put("Charm", "Strange");
    put("Top",   "Bottom");
}};

2番目の方法の1つの利点は、ラップして、Collections.unmodifiableMap()後でコレクションを更新するものがないことを保証できることです。

private static final Map<Integer, String> CONSTANT_MAP = 
    Collections.unmodifiableMap(new HashMap<Integer, String>() {{ 
        put(1, "one");
        put(2, "two");
    }});

 // later on...

 CONSTANT_MAP.put(3, "three"); // going to throw an exception!

Java 8の1行の静的マップ初期化子を次に示します。

private static final Map<String, String> EXTENSION_TO_MIMETYPE =
    Arrays.stream(new String[][] {
        { "txt", "text/plain" }, 
        { "html", "text/html" }, 
        { "js", "application/javascript" },
        { "css", "text/css" },
        { "xml", "application/xml" },
        { "png", "image/png" }, 
        { "gif", "image/gif" }, 
        { "jpg", "image/jpeg" },
        { "jpeg", "image/jpeg" }, 
        { "svg", "image/svg+xml" },
    }).collect(Collectors.toMap(kv -> kv[0], kv -> kv[1]));

編集：Map<Integer, String>質問のようにaを初期化するには、次のようなものが必要です：

static final Map<Integer, String> MY_MAP = Arrays.stream(new Object[][]{
        {1, "one"},
        {2, "two"},
}).collect(Collectors.toMap(kv -> (Integer) kv[0], kv -> (String) kv[1]));

Edit（2）：new SimpleEntry<>(k, v)呼び出しのストリームを使用する、i_am_zeroによるより良い混合型対応バージョンがあります。その答えを確認してください：https : //stackoverflow.com/a/37384773/3950982

Map.of Java 9以降

private static final Map<Integer, String> MY_MAP = Map.of(1, "one", 2, "two");

詳細については、JEP 269を参照してください。JDK 9は2017年9月に一般提供を開始しました。

Java 9

を使用Map.ofEntriesして呼び出しMap.entry( k , v )、各エントリを作成できます。

import static java.util.Map.entry;
private static final Map<Integer,String> map = Map.ofEntries(
        entry(1, "one"),
        entry(2, "two"),
        entry(3, "three"),
        entry(4, "four"),
        entry(5, "five"),
        entry(6, "six"),
        entry(7, "seven"),
        entry(8, "eight"),
        entry(9, "nine"),
        entry(10, "ten"));

ここMap.ofでの彼の回答で示唆されているように、Tagirが使用することもできますが、を使用して10エントリを超えることはできませんMap.of。

Java 8（きちんとしたソリューション）

マップエントリのストリームを作成できます。我々はすでにの2つの実装持ちEntryでjava.util.AbstractMapあるSimpleEntryとSimpleImmutableEntryを。この例では、前者を次のように使用できます。

import java.util.AbstractMap.*;
private static final Map<Integer, String> myMap = Stream.of(
            new SimpleEntry<>(1, "one"),
            new SimpleEntry<>(2, "two"),
            new SimpleEntry<>(3, "three"),
            new SimpleEntry<>(4, "four"),
            new SimpleEntry<>(5, "five"),
            new SimpleEntry<>(6, "six"),
            new SimpleEntry<>(7, "seven"),
            new SimpleEntry<>(8, "eight"),
            new SimpleEntry<>(9, "nine"),
            new SimpleEntry<>(10, "ten"))
            .collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));

Eclipseのコレクションは、次のすべてが動作します：

import java.util.Map;

import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.factory.Maps;

public class StaticMapsTest
{
    private static final Map<Integer, String> MAP =
        Maps.mutable.with(1, "one", 2, "two");

    private static final MutableMap<Integer, String> MUTABLE_MAP =
       Maps.mutable.with(1, "one", 2, "two");


    private static final MutableMap<Integer, String> UNMODIFIABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").asUnmodifiable();


    private static final MutableMap<Integer, String> SYNCHRONIZED_MAP =
        Maps.mutable.with(1, "one", 2, "two").asSynchronized();


    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").toImmutable();


    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP2 =
        Maps.immutable.with(1, "one", 2, "two");
}

Eclipseコレクションを使用して、プリミティブマップを静的に初期化することもできます。

import org.eclipse.collections.api.map.primitive.ImmutableIntObjectMap;
import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
import org.eclipse.collections.impl.factory.primitive.IntObjectMaps;

public class StaticPrimitiveMapsTest
{
    private static final MutableIntObjectMap<String> MUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two");

    private static final MutableIntObjectMap<String> UNMODIFIABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asUnmodifiable();

    private static final MutableIntObjectMap<String> SYNCHRONIZED_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asSynchronized();

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .toImmutable();

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP2 =
            IntObjectMaps.immutable.<String>empty()
                    .newWithKeyValue(1, "one")
                    .newWithKeyValue(2, "two");
} 

注：私はEclipseコレクションのコミッターです

この状況では、匿名サブクラスを作成することはありません。たとえば、マップを変更不可にしたい場合は、静的初期化子も同様に機能します。

private static final Map<Integer, String> MY_MAP;
static
{
    Map<Integer, String>tempMap = new HashMap<Integer, String>();
    tempMap.put(1, "one");
    tempMap.put(2, "two");
    MY_MAP = Collections.unmodifiableMap(tempMap);
}

多分それは彼らが彼らのページに持っているビデオなどのGoogleコレクションをチェックするのは面白いです。マップとセットを初期化するさまざまな方法を提供し、不変のコレクションも提供します。

更新：このライブラリの名前はGuavaになりました。

それを扱うのは簡単なので、私は匿名クラスが好きです：

public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() {
    {
        put(1, "some value");
                    //rest of code here
    }
});

public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);
    }
}

複数の定数を宣言すると、そのコードは静的ブロックで記述され、将来の維持が難しくなります。したがって、匿名クラスを使用することをお勧めします。

public class Test {

    public static final Map numbers = Collections.unmodifiableMap(new HashMap(2, 1.0f){
        {
            put(1, "one");
            put(2, "two");
        }
    });
}

また、定数としてunmodifiableMapを使用することをお勧めします。そうしないと、定数として処理できません。

静的ブロックスタイルよりも「ダブルブレース初期化」スタイルを強くお勧めします。

誰かが匿名クラス、オーバーヘッド、パフォーマンスなどを好まないとコメントするかもしれません。

しかし、私がより考慮すべきことは、コードの可読性と保守性です。この観点から、私は、二重ブレースが静的メソッドよりも優れたコードスタイルであると思います。

1. 要素はネストされ、インライン化されます。
2. 手続き型ではなく、オブジェクト指向です。
3. パフォーマンスへの影響は非常に小さく、無視できます。
4. IDEのアウトラインサポートの向上（多くの匿名静的{}ブロックではなく）
5. あなたはそれらの関係をもたらすためにコメントの数行を保存しました。
6. 初期化されていないオブジェクトのエレメントリーク/インスタンスリードが例外およびバイトコードオプティマイザから発生する可能性を防止します。
7. 静的ブロックの実行順序を気にする必要はありません。

さらに、匿名クラスのGCを認識している場合は、を使用していつでも通常のHashMapに変換できますnew HashMap(Map map)。

別の問題に直面するまで、これを行うことができます。その場合は、完全な別のコーディングスタイル（静的でないファクトリクラスなど）を使用する必要があります。

通常どおり、apache-commonsには適切なメソッドMapUtils.putAll（Map、Object []）があります。

たとえば、カラーマップを作成するには：

Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}
 });

Guavaを使用したくない（または使用できない）場合ImmutableMap.of()、または変更可能なものが必要な場合の私のお気に入りはMap次のとおりです。

public static <A> Map<String, A> asMap(Object... keysAndValues) {
    return new LinkedHashMap<String, A>() {{
        for (int i = 0; i < keysAndValues.length - 1; i++) {
            put(keysAndValues[i].toString(), (A) keysAndValues[++i]);
        }
    }};
}

これは非常にコンパクトで、浮遊値（つまり、値のない最後のキー）を無視します。

使用法：

Map<String, String> one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal");
Map<String, Object> two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2));

変更不可能なマップが必要な場合は、最後にJava 9 ofがMapインターフェースにクールなファクトリーメソッドを追加しました。同様のメソッドがSet、Listにも追加されています。

Map<String, String> unmodifiableMap = Map.of("key1", "value1", "key2", "value2");

匿名のクラス（それ以上の目的はない）を生成しないようにするために、静的初期化子を使用することを好むので、静的初期化子で初期化するヒントをリストします。リストされているすべての解決策/ヒントはタイプセーフです。

注：この質問では、マップを変更不可にすることについては何も述べられていないため、省略しますが、で簡単に実行できることを知っていますCollections.unmodifiableMap(map)。

最初のヒント

最初のヒントは、マップへのローカル参照を作成し、それにSHORT名を付けることです。

private static final Map<Integer, String> myMap = new HashMap<>();
static {
    final Map<Integer, String> m = myMap; // Use short name!
    m.put(1, "one"); // Here referencing the local variable which is also faster!
    m.put(2, "two");
    m.put(3, "three");
}

2番目のヒント

2番目のヒントは、エントリを追加するヘル​​パーメソッドを作成できることです。また、必要に応じて、このヘルパーメソッドをパブリックにすることもできます。

private static final Map<Integer, String> myMap2 = new HashMap<>();
static {
    p(1, "one"); // Calling the helper method.
    p(2, "two");
    p(3, "three");
}

private static void p(Integer k, String v) {
    myMap2.put(k, v);
}

ただし、ここでのヘルパーメソッドは、に要素を追加することしかできないため、再利用できませんmyMap2。再利用可能にするために、マップ自体をヘルパーメソッドのパラメーターにすることができますが、初期化コードは短くなりません。

3番目のヒント

3番目のヒントは、移植機能を備えた、再利用可能なビルダーのようなヘルパークラスを作成できることです。これは本当にタイプセーフなシンプルな10行のヘルパークラスです：

public class Test {
    private static final Map<Integer, String> myMap3 = new HashMap<>();
    static {
        new B<>(myMap3)   // Instantiating the helper class with our map
            .p(1, "one")
            .p(2, "two")
            .p(3, "three");
    }
}

class B<K, V> {
    private final Map<K, V> m;

    public B(Map<K, V> m) {
        this.m = m;
    }

    public B<K, V> p(K k, V v) {
        m.put(k, v);
        return this; // Return this for chaining
    }
}

作成している匿名クラスはうまく機能します。ただし、これは内部クラスであるため、周囲のクラスインスタンスへの参照が含まれることに注意してください。そのため、（XStreamを使用して）特定のことができないことがわかります。非常に奇妙なエラーが発生します。

そうは言っても、あなたが知っている限り、このアプローチは問題ありません。ほとんどの場合、あらゆる種類のコレクションを簡潔に初期化するために使用します。

編集：これは静的クラスであることをコメントで正しく指摘しました 明らかに私はこれを十分によく読みませんでした。ただし、私のコメントはまだ匿名の内部クラスに適用されます。

簡潔で比較的安全なものが必要な場合は、コンパイル時の型チェックをランタイムにシフトするだけです。

static final Map<String, Integer> map = MapUtils.unmodifiableMap(
    String.class, Integer.class,
    "cat",  4,
    "dog",  2,
    "frog", 17
);

この実装はエラーをキャッチする必要があります：

import java.util.HashMap;

public abstract class MapUtils
{
    private MapUtils() { }

    public static <K, V> HashMap<K, V> unmodifiableMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
            Object...keyValues)
    {
        return Collections.<K, V>unmodifiableMap(makeMap(
            keyClazz,
            valClazz,
            keyValues));
    }

    public static <K, V> HashMap<K, V> makeMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
            Object...keyValues)
    {
        if (keyValues.length % 2 != 0)
        {
            throw new IllegalArgumentException(
                    "'keyValues' was formatted incorrectly!  "
                  + "(Expected an even length, but found '" + keyValues.length + "')");
        }

        HashMap<K, V> result = new HashMap<K, V>(keyValues.length / 2);

        for (int i = 0; i < keyValues.length;)
        {
            K key = cast(keyClazz, keyValues[i], i);
            ++i;
            V val = cast(valClazz, keyValues[i], i);
            ++i;
            result.put(key, val);
        }

        return result;
    }

    private static <T> T cast(Class<? extends T> clazz, Object object, int i)
    {
        try
        {
            return clazz.cast(object);
        }
        catch (ClassCastException e)
        {
            String objectName = (i % 2 == 0) ? "Key" : "Value";
            String format = "%s at index %d ('%s') wasn't assignable to type '%s'";
            throw new IllegalArgumentException(String.format(format, objectName, i, object.toString(), clazz.getSimpleName()), e);
        }
    }
}

Java 8では、次のパターンを使用するようになりました。

private static final Map<String, Integer> MAP = Stream.of(
    new AbstractMap.SimpleImmutableEntry<>("key1", 1),
    new AbstractMap.SimpleImmutableEntry<>("key2", 2)
).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

それは最も簡潔で少しラウンドアバウトではありませんが、

• それ以外には何も必要ありません java.util
• タイプセーフであり、キーと値のさまざまなタイプに簡単に対応できます。

マップに値を1つだけ追加する必要がある場合は、Collections.singletonMapを使用できます。

Map<K, V> map = Collections.singletonMap(key, value)

あなたは使用することStickyMapとMapEntryからCactoos：

private static final Map<String, String> MAP = new StickyMap<>(
  new MapEntry<>("name", "Jeffrey"),
  new MapEntry<>("age", "35")
);

2番目のアプローチ（ダブルブレースの初期化）はアンチパターンと考えられていますであると考えられるため、最初のアプローチを採用します。

静的マップを初期化する別の簡単な方法は、このユーティリティ関数を使用することです。

public static <K, V> Map<K, V> mapOf(Object... keyValues) {
    Map<K, V> map = new HashMap<>(keyValues.length / 2);

    for (int index = 0; index < keyValues.length / 2; index++) {
        map.put((K)keyValues[index * 2], (V)keyValues[index * 2 + 1]);
    }

    return map;
}

Map<Integer, String> map1 = mapOf(1, "value1", 2, "value2");
Map<String, String> map2 = mapOf("key1", "value1", "key2", "value2");

注：Map.ofJava 9を使用できます

静的イニシャライザ構文が好きではないので、匿名サブクラスに確信が持てません。一般に、静的イニシャライザを使用することのすべての短所と、以前の回答で言及された匿名サブクラスを使用することのすべての短所に同意します。一方、これらの投稿で提示されたプロは私には十分ではありません。私は静的初期化メソッドを使用することを好みます：

public class MyClass {
    private static final Map<Integer, String> myMap = prepareMap();

    private static Map<Integer, String> prepareMap() {
        Map<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "one");
        hashMap.put(2, "two");

        return hashMap;
    }
}

私が使用する（そして好きになるようになっている）アプローチが回答に投稿されていないので、ここに示します。

静的なイニシャライザは扱いにくいので使用したくありません。また、インスタンスごとに新しいクラスを作成するため、匿名クラスは好きではありません。

代わりに、次のような初期化を好みます。

map(
    entry("keyA", "val1"),
    entry("keyB", "val2"),
    entry("keyC", "val3")
);

残念ながら、これらのメソッドは標準Javaライブラリの一部ではないため、次のメソッドを定義するユーティリティライブラリを作成（または使用）する必要があります。

 public static <K,V> Map<K,V> map(Map.Entry<K, ? extends V>... entries)
 public static <K,V> Map.Entry<K,V> entry(K key, V val)

（ 'import static'を使用して、メソッド名にプレフィックスを付ける必要を回避できます）

他のコレクション（list、set、sortedSet、sortedMapなど）に同様の静的メソッドを提供すると便利です

jsonオブジェクトの初期化ほど良くありませんが、読みやすさに関しては、その方向へのステップです。

Javaはマップリテラルをサポートしていないため、マップインスタンスは常に明示的にインスタンス化してデータを入力する必要があります。

さいわい、Javaでのマップリテラルの動作は、ファクトリメソッドを使用して概算できます。

例えば：

public class LiteralMapFactory {

    // Creates a map from a list of entries
    @SafeVarargs
    public static <K, V> Map<K, V> mapOf(Map.Entry<K, V>... entries) {
        LinkedHashMap<K, V> map = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : entries) {
            map.put(entry.getKey(), entry.getValue());
        }
        return map;
    }
    // Creates a map entry
    public static <K, V> Map.Entry<K, V> entry(K key, V value) {
        return new AbstractMap.SimpleEntry<>(key, value);
    }

    public static void main(String[] args) {
        System.out.println(mapOf(entry("a", 1), entry("b", 2), entry("c", 3)));
    }
}

出力：

{a = 1、b = 2、c = 3}

一度に要素をマップに作成して移入するよりもはるかに便利です。

JEP 269は、コレクションAPIのいくつかの便利なファクトリメソッドを提供します。このファクトリメソッドは現在のJavaバージョン（8）にはありませんが、Java 9リリースで計画されています。

以下のためにMapそこに2ファクトリメソッドは、次のとおりofとofEntries。を使用するとof、キーと値のペアを交互に渡すことができます。たとえば、いいMapね！を作成するには{age: 27, major: cs}：

Map<String, Object> info = Map.of("age", 27, "major", "cs");

現在、には10個のオーバーロードバージョンがあるためof、10個のキーと値のペアを含むマップを作成できます。この制限または交互のキー/値が気に入らない場合は、次を使用できますofEntries。

Map<String, Object> info = Map.ofEntries(
                Map.entry("age", 27),
                Map.entry("major", "cs")
);

ofとofEntriesはどちらも不変を返すMapため、構築後にそれらの要素を変更することはできません。JDK 9 Early Accessを使用してこれらの機能を試すことができます。

ええと...私は列挙型が好きです;）

enum MyEnum {
    ONE   (1, "one"),
    TWO   (2, "two"),
    THREE (3, "three");

    int value;
    String name;

    MyEnum(int value, String name) {
        this.value = value;
        this.name = name;
    }

    static final Map<Integer, String> MAP = Stream.of( values() )
            .collect( Collectors.toMap( e -> e.value, e -> e.name ) );
}

答えを読んだので、自分でマップビルダーを作成することにしました。コピー＆ペーストしてお楽しみください。

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

/**
 * A tool for easy creation of a map. Code example:<br/>
 * {@code MapBuilder.of("name", "Forrest").and("surname", "Gump").build()}
 * @param <K> key type (inferred by constructor)
 * @param <V> value type (inferred by constructor)
 * @author Vlasec (for http://stackoverflow.com/a/30345279/1977151)
 */
public class MapBuilder <K, V> {
    private Map<K, V> map = new HashMap<>();

    /** Constructor that also enters the first entry. */
    private MapBuilder(K key, V value) {
        and(key, value);
    }

    /** Factory method that creates the builder and enters the first entry. */
    public static <A, B> MapBuilder<A, B> mapOf(A key, B value) {
        return new MapBuilder<>(key, value);
    }

    /** Puts the key-value pair to the map and returns itself for method chaining */
    public MapBuilder<K, V> and(K key, V value) {
        map.put(key, value);
        return this;
    }

    /**
     * If no reference to builder is kept and both the key and value types are immutable,
     * the resulting map is immutable.
     * @return contents of MapBuilder as an unmodifiable map.
     */
    public Map<K, V> build() {
        return Collections.unmodifiableMap(map);
    }
}

編集：最近、私はパブリック静的メソッドを見つけ続けます ofかなり頻繁におり、私はそれがちょっと好きです。これをコードに追加してコンストラクタをプライベートにし、静的なファクトリメソッドパターンに切り替えました。

EDIT2：さらに最近では、of静的インポートを使用するとかなり悪いように見えるため、と呼ばれる静的メソッドはもはや好きではありません。mapOf代わりにに名前を変更して、静的インポートにより適したものにしました。