java - 静的マップを初期化するにはどうすればよいですか?

Question

MapJavaで静的をどのように初期化しますか?

方法 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");
        }
    };
}

score 1169 · Accepted Answer

この場合、インスタンス初期化子は単なるシンタックスシュガーですよね？初期化するためだけに追加の匿名クラスが必要な理由がわかりません。また、作成中のクラスが 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);
    }
}

score 468 · Accepted Answer

静的で不変のマップを初期化する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 の不変コレクションユーティリティの利点の詳細については、Immutable Collections Explained in Guava User Guide を参照してください。

(のサブセット) Guava はGoogle Collectionsと呼ばれていました。Java プロジェクトでこのライブラリをまだ使用していない場合は、試してみることを強くお勧めします。仲間の SO ユーザーが同意するように、Guava はすぐに Java 用の最も人気があり便利な無料のサードパーティライブラリの 1 つになりました。(初めての方は、そのリンクの背後に優れた学習リソースがいくつかあります。)

更新 (2015) : Java 8に関しては、他の何よりもクリーンであるため、Guava アプローチを引き続き使用します。Guava の依存関係が必要ない場合は、単純な古い init メソッドを検討してください。2 次元配列と Stream APIを使用したハックは、私に尋ねるとかなり見苦しく、キーと値が同じ型ではない Map を作成する必要がある場合 (Map<Integer, String>質問のように) はさらに醜くなります。

一般的な Guava の将来については、Java 8 に関して、Louis Wassermanが 2014 年にこれを述べ、[更新] 2016 年に、Guava 21 が Java 8 を必要とし、適切にサポートすることが発表されました。

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

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

score 197 · Accepted Answer

私は使うだろう：

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);
    }
}

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

score 188 · Accepted Answer

Java 5 では、次のよりコンパクトな構文が提供されます。

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

score 102 · Accepted Answer

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!

score 70 · Accepted Answer

`Map.of` in Java 9+

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

See JEP 269 for details. JDK 9 reached general availability in September 2017.

score 63 · Accepted Answer

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]));

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

score 53 · Accepted Answer

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

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

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));

score 31 · Accepted Answer

Eclipse Collectionsでは、次のすべてが機能します。

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 Collections のコミッターです。

score 29 · Accepted Answer

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

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);
}

score 18 · Accepted Answer

たぶん、 Googleコレクションをチェックするのは面白いでしょう。例えば、彼らが彼らのページに持っているビデオ。これらは、マップとセットを初期化するためのさまざまな方法を提供し、不変のコレクションも提供します。

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

score 17 · Accepted Answer

扱いやすいので、匿名クラスが好きです。

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

score 12 · Accepted Answer

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 を使用することをお勧めします。そうしないと、定数として扱うことができません。

score 10 · Accepted Answer

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

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

しかし、私がもっと考慮しているのは、コードの読みやすさと保守性です。この観点から、二重中括弧は静的メソッドよりも優れたコードスタイルであると私は考えています。

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

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

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

score 9 · Accepted Answer

いつものように、apache-commons には適切なメソッドMapUtils.putAll(Map, Object[])があります。

たとえば、カラーマップを作成するには、次のようにします。

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

score 8 · Accepted Answer

私だったらここがお気に入り

Guava を使用したくない (または使用できない)ImmutableMap.of()
または私はミュータブルが必要ですMap
Map.of()または、JDK9+ からの 10 エントリ制限を超える必要があります

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));

score 7 · Accepted Answer

私は静的イニシャライザを使用して匿名クラスを生成しないようにすることを好みます (それ以上の目的はありません)。リストされているすべてのソリューション/ヒントはタイプセーフです。

注:質問では、マップを変更不可にすることについては何も言われていないので、省略しますが、Collections.unmodifiableMap(map).

最初のヒント

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

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
    }
}

score 5 · Accepted Answer

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

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

編集:これが静的クラスであることをコメントで正しく指摘しました。明らかに、私はこれを十分によく読んでいませんでした。ただし、私のコメントは匿名の内部クラスにも当てはまります。

score 4 · Accepted Answer

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
タイプセーフであり、キーと値のさまざまなタイプに簡単に対応できます。

score 4 · Accepted Answer

CactoosからStickyMapとを使用できます:MapEntry

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

score 3 · Accepted Answer

私は静的イニシャライザの構文が好きではなく、匿名のサブクラスに納得していません。一般に、静的初期化子を使用することのすべての短所と、前の回答で言及された匿名サブクラスを使用することのすべての短所に同意します。一方、これらの投稿で紹介されている長所は、私にとって十分ではありません。私は静的な初期化方法を使用することを好みます:

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;
    }
}

score 2 · Accepted Answer

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

とのMap2 つのファクトリメソッドがofありofEntriesます。を使用するofと、キーと値のペアを交互に渡すことができます。たとえば、Maplikeを作成するには{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とは両方ともofEntriesimmutable を返すMapため、構築後にそれらの要素を変更することはできません。これらの機能は、 JDK 9 Early Accessを使用して試すことができます。

score 1 · Accepted Answer

これは Apache commons-lang を使用していますが、これは既にクラスパスにある可能性が高いです。

Map<String, String> collect = Stream.of(
        Pair.of("hello", "world"),
        Pair.of("abc", "123"),
        Pair.of("java", "eight")
).collect(Collectors.toMap(Pair::getKey, Pair::getValue));

score 1 · Accepted Answer

初期化コンストラクターを定義したがデフォルトコンストラクターを定義していない抽象クラスの具体的な実現があるが、サブクラスにデフォルトコンストラクターを持たせたい場合は、静的初期化子の「手法」を使用するのが好きです。

例えば：

public abstract class Shape {

    public static final String COLOR_KEY = "color_key";
    public static final String OPAQUE_KEY = "opaque_key";

    private final String color;
    private final Boolean opaque;

    /**
     * Initializing constructor - note no default constructor.
     *
     * @param properties a collection of Shape properties
     */
    public Shape(Map<String, Object> properties) {
        color = ((String) properties.getOrDefault(COLOR_KEY, "black"));
        opaque = (Boolean) properties.getOrDefault(OPAQUE_KEY, false);
    }

    /**
     * Color property accessor method.
     *
     * @return the color of this Shape
     */
    public String getColor() {
        return color;
    }

    /**
     * Opaque property accessor method.
     *
     * @return true if this Shape is opaque, false otherwise
     */
    public Boolean isOpaque() {
        return opaque;
    }
}

そして、このクラスの私の具体的な実現-しかし、デフォルトのコンストラクターが必要/必要です:

public class SquareShapeImpl extends Shape {

    private static final Map<String, Object> DEFAULT_PROPS = new HashMap<>();

    static {
        DEFAULT_PROPS.put(Shape.COLOR_KEY, "yellow");
        DEFAULT_PROPS.put(Shape.OPAQUE_KEY, false);
    }

    /**
     * Default constructor -- intializes this square to be a translucent yellow
     */
    public SquareShapeImpl() {
        // the static initializer was useful here because the call to 
        // this(...) must be the first statement in this constructor
        // i.e., we can't be mucking around and creating a map here
        this(DEFAULT_PROPS);
    }

    /**
     * Initializing constructor -- create a Square with the given
     * collection of properties.
     *
     * @param props a collection of properties for this SquareShapeImpl
     */
    public SquareShapeImpl(Map<String, Object> props) {
        super(props);
    }
}

次に、このデフォルトのコンストラクターを使用するには、次のようにします。

public class StaticInitDemo {

    public static void main(String[] args) {

        // create a translucent, yellow square...
        Shape defaultSquare = new SquareShapeImpl();

        // etc...
    }
}

score 0 · Accepted Answer

私は少し違うことをしました。最高ではありませんが、私にとってはうまくいきます。多分それは「一般化された」かもしれません。

private static final Object[][] ENTRIES =
{
  {new Integer(1), "one"},
  {new Integer(2), "two"},
};
private static final Map myMap = newMap(ENTRIES);

private static Map newMap(Object[][] entries)
{
  Map map = new HashMap();

  for (int x = 0; x < entries.length; x++)
  {
    Object[] entry = entries[x];

    map.put(entry[0], entry[1]);
  }

  return map;
}

score 0 · Accepted Answer

データの String 表現を使用できる場合、これは Java 8 でもオプションです。

static Map<Integer, String> MAP = Stream.of(
        "1=one",
        "2=two"
).collect(Collectors.toMap(k -> Integer.parseInt(k.split("=")[0]), v -> v.split("=")[1]));

score 0 · Accepted Answer

ここにAbacusUtilによるコードがあります

Map<Integer, String> map = N.asMap(1, "one", 2, "two");
// Or for Immutable map 
ImmutableMap<Integer, String> = ImmutableMap.of(1, "one", 2, "two");

宣言：私は AbacusUtil の開発者です。

score 0 · Accepted Answer

ここにはいくつかの良い答えがありますが、もう1つ提供したいと思います。

を作成および初期化するための独自の静的メソッドを作成しますMap。私は、CollectionUtils定期的に使用するさまざまなユーティリティを含むプロジェクト全体で使用するパッケージに独自のクラスを用意しています。これらのユーティリティは、簡単に記述でき、より大きなライブラリへの依存の必要性を回避します。

これが私のnewMap方法です：

public class CollectionUtils {
    public static Map newMap(Object... keyValuePairs) {
        Map map = new HashMap();
        if ( keyValuePairs.length % 2 == 1 ) throw new IllegalArgumentException("Must have even number of arguments");
        for ( int i=0; i<keyValuePairs.length; i+=2 ) {
            map.put(keyValuePairs[i], keyValuePairs[i + 1]);
        }
        return map;
    }
}

使用法：

import static CollectionUtils.newMap;
// ...
Map aMap = newMap("key1", 1.23, "key2", 2.34);
Map bMap = newMap(objKey1, objVal1, objKey2, objVal2, objKey3, objVal3);
// etc...

ジェネリックは使用しませんが、必要に応じてマップを型キャストできます (型キャストが正しく行われていることを確認してください!)。

Map<String,Double> aMap = (Map<String,Double>)newMap("key1", 1.23, "key2", 2.34);

score 0 · Accepted Answer

Java 8 では、手続き型アプローチを次のようにラップすることもできますSupplier。

Map<String,String> m = ((Supplier<Map<String,String>>)(() -> {
    Map<String,String> result = new HashMap<>();
    result.put("foo","hoo");
    ...
    return result;
)).get();

これは架空の方法ですが、本当にワンライナーが必要な場合に便利です。

score 0 · Accepted Answer

2 番目のメソッドは、必要に応じて保護されたメソッドを呼び出すことができます。これは、構築後に不変なクラスを初期化するのに役立ちます。

java - 静的マップを初期化するにはどうすればよいですか?

43 に答える 43

Map.of in Java 9+

Java 9

Java 8

Related

Reference

`Map.of` in Java 9+