Bagaimana Anda menginisialisasi statis Mapdi Jawa?

Metode satu: penginisialisasi statis
Metode dua: penginisialisasi instance (subclass anonim) atau metode lain?

Apa pro dan kontra dari masing-masing?

Berikut adalah contoh yang menggambarkan dua metode:

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

Inisialisasi instance hanya gula sintaksis dalam kasus ini, kan? Saya tidak mengerti mengapa Anda perlu kelas anonim tambahan hanya untuk menginisialisasi. Dan itu tidak akan berhasil jika kelas yang dibuat adalah final.

Anda dapat membuat peta abadi menggunakan penginisialisasi statis juga:

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

Saya suka cara Jambu menginisialisasi peta statis yang tidak dapat diubah:

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

Seperti yang Anda lihat, ini sangat ringkas (karena metode pabrik yang mudah digunakan ImmutableMap).

Jika Anda ingin peta memiliki lebih dari 5 entri, Anda tidak dapat lagi menggunakan ImmutableMap.of(). Alih-alih, coba ImmutableMap.builder()di bawah ini:

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

Untuk mempelajari lebih lanjut tentang manfaat dari utilitas pengumpulan yang tidak berubah oleh Guava, lihat Koleksi Tidak Berubah yang Dijelaskan dalam Panduan Pengguna Guava .

(Subset dari) Jambu biji dulu disebut Google Collections . Jika Anda belum menggunakan pustaka ini dalam proyek Java Anda, saya sangat merekomendasikan untuk mencobanya! Guava dengan cepat menjadi salah satu libs pihak ke-3 gratis yang paling populer dan bermanfaat untuk Java, seperti yang disetujui oleh sesama pengguna SO . (Jika Anda baru mengenalnya, ada beberapa sumber belajar yang sangat baik di balik tautan itu.)

Pembaruan (2015) : Adapun Java 8 , well, saya masih akan menggunakan pendekatan Guava karena jauh lebih bersih daripada yang lain. Jika Anda tidak ingin ketergantungan jambu biji, pertimbangkan metode init lama biasa . Peretasan dengan array dua dimensi dan Stream API sangat jelek jika Anda bertanya kepada saya, dan menjadi lebih buruk jika Anda perlu membuat Peta yang kunci dan nilainya bukan tipe yang sama (seperti Map<Integer, String>dalam pertanyaan).

Adapun masa depan Guava secara umum, sehubungan dengan Java 8, Louis Wasserman mengatakan ini kembali pada tahun 2014, dan [ pembaruan ] pada tahun 2016 diumumkan bahwa Guava 21 akan membutuhkan dan mendukung Java 8 dengan baik .

Pembaruan (2016) : Seperti yang ditunjukkan Tagir Valeev , Java 9 pada akhirnya akan membuat hal ini bersih dengan menggunakan JDK murni, dengan menambahkan metode pabrik yang praktis untuk koleksi:

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

Saya akan menggunakan:

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. itu menghindari kelas anonim, yang saya pribadi anggap sebagai gaya yang buruk, dan hindari
2. itu membuat pembuatan peta lebih eksplisit
3. itu membuat peta tidak dapat dimodifikasi
4. karena MY_MAP adalah konstan, saya akan menamainya seperti konstan

Java 5 menyediakan sintaks yang lebih ringkas ini:

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

Satu keuntungan dari metode kedua adalah Anda dapat membungkusnya dengan Collections.unmodifiableMap()untuk memastikan bahwa tidak ada yang akan memperbarui koleksi nanti:

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!

Berikut adalah penginisialisasi peta statis satu baris Java 8:

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

Sunting: untuk menginisialisasi a Map<Integer, String>seperti pada pertanyaan, Anda memerlukan sesuatu seperti ini:

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

Sunting (2): Ada versi yang lebih baik, tipe campuran yang mampu oleh i_am_zero yang menggunakan aliran new SimpleEntry<>(k, v)panggilan. Lihat jawaban itu: https://stackoverflow.com/a/37384773/3950982

Map.of di Jawa 9+

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

Lihat JEP 269 untuk detailnya. JDK 9 mencapai ketersediaan umum pada bulan September 2017.

Jawa 9

Kita dapat menggunakan Map.ofEntries, memanggil Map.entry( k , v )untuk membuat setiap entri.

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

Kita juga dapat menggunakan Map.ofseperti yang disarankan oleh Tagir dalam jawabannya di sini tetapi kita tidak dapat menggunakan lebih dari 10 entriMap.of .

Java 8 (Solusi Rapi)

Kami dapat membuat Stream entri peta. Kita sudah memiliki dua implementasi dari Entrydalam java.util.AbstractMapyang SimpleEntry dan SimpleImmutableEntry . Untuk contoh ini kita dapat menggunakan yang pertama sebagai:

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

Dengan Eclipse Collections , semua hal berikut ini akan berfungsi:

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

Anda juga dapat secara statis menginisialisasi peta primitif dengan Eclipse Collections.

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

Catatan: Saya pengendara untuk Eclipse Collections

Saya tidak akan pernah membuat subclass anonim dalam situasi ini. Inisialisasi statis berfungsi sama baiknya, jika Anda ingin membuat peta tidak dapat dimodifikasi, misalnya:

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

Mungkin menarik untuk memeriksa Google Collections , misalnya video yang mereka miliki di halaman mereka. Mereka menyediakan berbagai cara untuk menginisialisasi peta dan set, dan juga menyediakan koleksi yang tidak berubah.

Pembaruan: Perpustakaan ini sekarang bernama Guava .

Saya suka kelas anonim, karena mudah ditangani:

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

Jika kita mendeklarasikan lebih dari satu konstanta maka kode itu akan ditulis dalam blok statis dan itu sulit dipertahankan di masa depan. Jadi lebih baik menggunakan kelas anonim.

public class Test {

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

Dan disarankan untuk menggunakan peta yang tidak dapat dimodifikasi untuk konstanta selain itu tidak dapat diperlakukan sebagai konstanta.

Saya sangat menyarankan gaya "inisialisasi penjepit ganda" atas gaya blok statis.

Seseorang mungkin berkomentar bahwa mereka tidak suka kelas anonim, overhead, kinerja, dll.

Tapi yang lebih saya pertimbangkan adalah pembacaan kode dan rawatan. Dalam sudut pandang ini, saya berdiri penyangga ganda adalah gaya kode yang lebih baik daripada metode statis.

1. Elemen-elemen tersebut bersarang dan sejajar.
2. Ini lebih OO, bukan prosedural.
3. dampak kinerja sangat kecil dan dapat diabaikan.
4. Dukungan IDE garis besar (daripada banyak blok statis {} anonim)
5. Anda menyimpan beberapa baris komentar untuk memberi mereka hubungan.
6. Mencegah kemungkinan kebocoran elemen / instance dari objek yang tidak diinisialisasi dari pengecualian dan pengoptimal bytecode.
7. Tidak perlu khawatir dengan urutan eksekusi blok statis.

Selain itu, jika Anda mengetahui GC dari kelas anonim, Anda selalu dapat mengonversinya menjadi HashMap normal dengan menggunakan new HashMap(Map map).

Anda dapat melakukan ini sampai Anda menghadapi masalah lain. Jika ya, Anda harus menggunakan melengkapi gaya pengkodean lain (mis. Tidak ada kelas statis, pabrik) untuk itu.

Seperti biasa apache-commons memiliki metode MapUtils.putAll (Map, Object []) yang tepat :

Misalnya, untuk membuat peta warna:

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

Inilah favorit saya ketika saya tidak ingin (atau tidak bisa) menggunakan Guava ImmutableMap.of(), atau jika saya perlu bisa berubah 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]);
        }
    }};
}

Ini sangat kompak, dan mengabaikan nilai-nilai liar (yaitu kunci terakhir tanpa nilai).

Pemakaian:

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

Jika Anda ingin peta yang tidak dapat dimodifikasi, akhirnya java 9 menambahkan metode pabrik keren ofke Mapantarmuka. Metode serupa ditambahkan ke Set, List juga.

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

Saya lebih suka menggunakan penginisialisasi statis untuk menghindari menghasilkan kelas anonim (yang tidak memiliki tujuan lebih lanjut), jadi saya akan daftar tips inisialisasi dengan penginisialisasi statis. Semua solusi / tip yang tercantum adalah tipe-aman.

Catatan: Pertanyaannya tidak mengatakan apa pun tentang membuat peta tidak dapat dimodifikasi, jadi saya akan mengabaikannya, tetapi tahu bahwa itu dapat dengan mudah dilakukan Collections.unmodifiableMap(map).

Kiat pertama

Kiat pertama adalah Anda dapat membuat referensi lokal ke peta dan Anda memberinya nama PENDEK:

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

Tip kedua

Kiat kedua adalah Anda bisa membuat metode pembantu untuk menambahkan entri; Anda juga dapat membuat metode penolong ini menjadi publik jika Anda ingin:

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

Metode helper di sini tidak dapat digunakan kembali karena hanya dapat menambahkan elemen myMap2. Untuk membuatnya dapat digunakan kembali, kita bisa menjadikan peta itu sendiri sebagai parameter dari metode helper, tetapi kemudian kode inisialisasi tidak akan lebih pendek.

Tip ketiga

Kiat ke-3 adalah Anda dapat membuat kelas pembantu seperti pembangun yang dapat digunakan kembali dengan fungsionalitas populating. Ini benar-benar kelas pembantu sederhana 10-baris yang aman untuk jenis:

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

Kelas anonim yang Anda buat berfungsi dengan baik. Namun Anda harus menyadari bahwa ini adalah kelas dalam dan karenanya, itu akan berisi referensi ke instance kelas sekitarnya. Jadi Anda akan menemukan bahwa Anda tidak dapat melakukan hal-hal tertentu dengannya (menggunakan XStream untuk satu). Anda akan mendapatkan beberapa kesalahan yang sangat aneh.

Karena itu, selama Anda sadar maka pendekatan ini baik-baik saja. Saya menggunakannya sebagian besar waktu untuk menginisialisasi semua jenis koleksi secara ringkas.

EDIT: Tunjukkan dengan benar di komentar bahwa ini adalah kelas statis. Jelas saya tidak cukup membaca ini. Namun komentar saya lakukan masih berlaku untuk kelas batin anonim.

Jika Anda menginginkan sesuatu yang singkat dan relatif aman, Anda bisa mengubah pemeriksaan tipe kompilasi menjadi run-time:

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

Implementasi ini harus menangkap kesalahan:

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

Dengan Java 8 saya datang untuk menggunakan pola berikut:

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

Ini bukan yang paling singkat dan agak bundaran, tapi

• tidak memerlukan apa pun di luar java.util
• itu aman dan mudah mengakomodasi berbagai jenis kunci dan nilai.

Jika Anda hanya perlu menambahkan satu nilai ke peta, Anda dapat menggunakan Collections.singletonMap :

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

Anda dapat menggunakan StickyMapdan MapEntrydari Cactoos :

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

Pendekatan kedua Anda (inisialisasi Double Brace) dianggap sebagai pola anti , jadi saya akan menggunakan pendekatan pertama.

Cara mudah lain untuk menginisialisasi Peta statis adalah dengan menggunakan fungsi utilitas ini:

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

Catatan: Java 9Anda dapat menggunakan Map.of

Saya tidak suka sintaks initializer Static dan saya tidak yakin dengan subclass anonim. Secara umum, saya setuju dengan semua kontra menggunakan inisialisasi Static dan semua kontra menggunakan subclass anonim yang disebutkan dalam jawaban sebelumnya. Di sisi lain - pro yang disajikan dalam posting ini tidak cukup untuk saya. Saya lebih suka menggunakan metode inisialisasi statis:

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

Saya belum melihat pendekatan yang saya gunakan (dan semakin menyukai) yang diposting dalam jawaban apa pun, jadi ini dia:

Saya tidak suka menggunakan inisialisasi statis karena mereka kikuk, dan saya tidak suka kelas anonim karena membuat kelas baru untuk setiap contoh.

sebagai gantinya, saya lebih suka inisialisasi yang terlihat seperti ini:

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

sayangnya, metode ini bukan bagian dari pustaka Java standar, jadi Anda perlu membuat (atau menggunakan) pustaka utilitas yang mendefinisikan metode berikut:

 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)

(Anda dapat menggunakan 'impor statis' untuk menghindari keharusan awalan nama metode)

Saya merasa bermanfaat untuk menyediakan metode statis yang serupa untuk koleksi lainnya (daftar, set, setel Urutkan, Urutkan Peta, dll.)

Ini tidak sebagus inisialisasi objek json, tapi ini adalah langkah ke arah itu, sejauh menyangkut keterbacaan.

Karena Java tidak mendukung peta literal, instance peta harus selalu dibuat secara eksplisit dan dihuni.

Untungnya, dimungkinkan untuk memperkirakan perilaku literal peta di Jawa menggunakan metode pabrik .

Sebagai contoh:

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

Keluaran:

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

Ini jauh lebih nyaman daripada membuat dan mengisi elemen peta pada suatu waktu.

JEP 269 menyediakan beberapa metode pabrik praktis untuk Collections API. Metode pabrik ini tidak dalam versi Java saat ini, yaitu 8, tetapi direncanakan untuk rilis Java 9.

Karena Mapada dua metode pabrik: ofdan ofEntries. Menggunakan of, Anda dapat melewati pasangan kunci / nilai bolak-balik. Misalnya, untuk membuat Mapsejenis {age: 27, major: cs}:

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

Saat ini ada sepuluh versi kelebihan beban of, sehingga Anda dapat membuat peta yang berisi sepuluh pasangan kunci / nilai. Jika Anda tidak menyukai batasan ini atau kunci / nilai yang berganti-ganti, Anda dapat menggunakan ofEntries:

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

Keduanya ofdan ofEntriesakan mengembalikan yang tidak berubah Map, sehingga Anda tidak dapat mengubah elemen mereka setelah konstruksi. Anda dapat mencoba fitur-fitur ini menggunakan JDK 9 Early Access .

Yah ... saya suka enum;)

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

Saya sudah membaca jawabannya dan saya memutuskan untuk menulis pembuat peta saya sendiri. Jangan ragu untuk menyalin dan menempel.

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

EDIT: Akhir-akhir ini, saya terus menemukan metode statis publik ofcukup sering dan saya agak menyukainya. Saya menambahkannya ke dalam kode dan menjadikan konstruktor sebagai pribadi, sehingga beralih ke pola metode pabrik statis.

EDIT2: Bahkan lebih baru-baru ini, saya tidak lagi suka metode statis yang disebut of, karena terlihat sangat buruk ketika menggunakan impor statis. Saya mengganti namanya menjadi mapOf, membuatnya lebih cocok untuk impor statis.