Apakah ada cara untuk menginisialisasi Java HashMap seperti ini ?:

Map<String,String> test = 
    new HashMap<String, String>{"test":"test","test":"test"};

Apa yang akan menjadi sintaks yang benar? Saya belum menemukan apa pun mengenai hal ini. Apakah ini mungkin? Saya mencari cara terpendek / tercepat untuk meletakkan beberapa nilai "final / statis" di peta yang tidak pernah berubah dan diketahui sebelumnya saat membuat Peta.

Semua versi

Jika Anda membutuhkan hanya satu entri: Ada Collections.singletonMap("key", "value").

Untuk Java Versi 9 atau lebih tinggi:

Ya, ini mungkin sekarang. Di Jawa 9 beberapa metode pabrik telah ditambahkan yang menyederhanakan pembuatan peta:

// this works for up to 10 elements:
Map<String, String> test1 = Map.of(
    "a", "b",
    "c", "d"
);

// this works for any number of elements:
import static java.util.Map.entry;    
Map<String, String> test2 = Map.ofEntries(
    entry("a", "b"),
    entry("c", "d")
);

Dalam contoh di atas keduanya testdan test2akan sama, hanya dengan berbagai cara mengekspresikan Peta. The Map.ofMetode didefinisikan sampai elemen sepuluh di peta, sedangkan Map.ofEntriesmetode tidak akan memiliki batas tersebut.

Perhatikan bahwa dalam hal ini peta yang dihasilkan akan menjadi peta yang tidak berubah. Jika Anda ingin peta dapat diubah, Anda dapat menyalinnya lagi, misalnya menggunakanmutableMap = new HashMap<>(Map.of("a", "b"));

(Lihat juga JEP 269 dan Javadoc )

Untuk versi Java hingga 8:

Tidak, Anda harus menambahkan semua elemen secara manual. Anda dapat menggunakan penginisialisasi dalam subkelas anonim untuk membuat sintaks sedikit lebih pendek:

Map<String, String> myMap = new HashMap<String, String>() {{
        put("a", "b");
        put("c", "d");
    }};

Namun, subclass anonim mungkin memperkenalkan perilaku yang tidak diinginkan dalam beberapa kasus. Ini termasuk misalnya:

• Ini menghasilkan kelas tambahan yang meningkatkan konsumsi memori, konsumsi ruang disk, dan waktu mulai
• Dalam kasus metode non-statis: Ini memegang referensi ke objek metode pembuatan dipanggil. Itu berarti objek dari kelas luar tidak bisa menjadi sampah yang dikumpulkan ketika objek peta yang dibuat masih dirujuk, sehingga memblokir memori tambahan

Menggunakan fungsi untuk inisialisasi juga akan memungkinkan Anda untuk menghasilkan peta dalam penginisialisasi, tetapi menghindari efek samping yang buruk:

Map<String, String> myMap = createMap();

private static Map<String, String> createMap() {
    Map<String,String> myMap = new HashMap<String,String>();
    myMap.put("a", "b");
    myMap.put("c", "d");
    return myMap;
}

Ini satu arah.

HashMap<String, String> h = new HashMap<String, String>() {{
    put("a","b");
}};

Namun, Anda harus berhati-hati dan memastikan bahwa Anda memahami kode di atas (ini menciptakan kelas baru yang diwarisi dari HashMap). Karenanya, Anda harus membaca lebih lanjut di sini: http://www.c2.com/cgi/wiki?DoubleBraceInisialisasi , atau cukup gunakan Guava:

Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);

Jika Anda membiarkan libs pihak ke-3, Anda dapat menggunakan Jambu 's ImmutableMap untuk mencapai literal seperti singkatnya:

Map<String, String> test = ImmutableMap.of("k1", "v1", "k2", "v2");

Ini berfungsi hingga 5 pasangan kunci / nilai , jika tidak Anda dapat menggunakan pembuatnya :

Map<String, String> test = ImmutableMap.<String, String>builder()
    .put("k1", "v1")
    .put("k2", "v2")
    ...
    .build();

• perhatikan bahwa implementasi ImmutableMap Guava berbeda dari Java HashMap implementasi (terutama itu tidak berubah dan tidak mengizinkan kunci / nilai null)
• untuk info lebih lanjut, lihat artikel panduan pengguna Guava tentang jenis koleksi yang tidak berubah

Tidak ada cara langsung untuk melakukan ini - Java tidak memiliki literal Peta (belum - saya pikir mereka diusulkan untuk Java 8).

Beberapa orang menyukai ini:

Map<String,String> test = new HashMap<String, String>(){{
       put("test","test"); put("test","test");}};

Ini menciptakan subclass anonim dari HashMap, yang penginisiasinya instan menempatkan nilai-nilai ini. (Omong-omong, peta tidak dapat memuat dua kali nilai yang sama, put kedua Anda akan menimpa yang pertama. Saya akan menggunakan nilai yang berbeda untuk contoh berikutnya.)

Cara normal adalah ini (untuk variabel lokal):

Map<String,String> test = new HashMap<String, String>();
test.put("test","test");
test.put("test1","test2");

Jika testpeta Anda adalah variabel instan, masukkan inisialisasi ke konstruktor atau inisialisasi instance:

Map<String,String> test = new HashMap<String, String>();
{
    test.put("test","test");
    test.put("test1","test2");
}

Jika testpeta Anda adalah variabel kelas, letakkan inisialisasi dalam penginisialisasi statis:

static Map<String,String> test = new HashMap<String, String>();
static {
    test.put("test","test");
    test.put("test1","test2");
}

Jika Anda ingin peta Anda tidak pernah berubah, Anda harus setelah inisialisasi membungkus peta Anda dengan Collections.unmodifiableMap(...). Anda dapat melakukan ini di penginisialisasi statis juga:

static Map<String,String> test;
{
    Map<String,String> temp = new HashMap<String, String>();
    temp.put("test","test");
    temp.put("test1","test2");
    test = Collections.unmodifiableMap(temp);
}

(Saya tidak yakin apakah Anda sekarang dapat membuat testfinal ... coba dan laporkan di sini.)

Map<String,String> test = new HashMap<String, String>()
{
    {
        put(key1, value1);
        put(key2, value2);
    }
};

Alternatif, menggunakan kelas Java 7 dan varargs polos: buat kelas HashMapBuilderdengan metode ini:

public static HashMap<String, String> build(String... data){
    HashMap<String, String> result = new HashMap<String, String>();

    if(data.length % 2 != 0) 
        throw new IllegalArgumentException("Odd number of arguments");      

    String key = null;
    Integer step = -1;

    for(String value : data){
        step++;
        switch(step % 2){
        case 0: 
            if(value == null)
                throw new IllegalArgumentException("Null key value"); 
            key = value;
            continue;
        case 1:             
            result.put(key, value);
            break;
        }
    }

    return result;
}

Gunakan metode seperti ini:

HashMap<String,String> data = HashMapBuilder.build("key1","value1","key2","value2");

tl; dr

Gunakan Map.of…metode di Java 9 dan yang lebih baru.

Map< String , String > animalSounds =
    Map.of(
        "dog"  , "bark" ,   // key , value
        "cat"  , "meow" ,   // key , value
        "bird" , "chirp"    // key , value
    )
;

Map.of

Java 9 menambahkan serangkaian Map.ofmetode statis untuk melakukan apa yang Anda inginkan: Buat Instantiate Mapmenggunakan sintaks literal .

Peta (kumpulan entri) tidak dapat diubah, sehingga Anda tidak dapat menambah atau menghapus entri setelah membuat instance. Juga, kunci dan nilai setiap entri tidak berubah, tidak dapat diubah. Lihat Javadoc untuk aturan lain, seperti tidak ada NULL diizinkan, tidak ada kunci duplikat diizinkan, dan urutan iterasi pemetaan adalah arbitrer.

Mari kita lihat metode-metode ini, menggunakan beberapa sampel data untuk peta hari-minggu ke seseorang yang kita harapkan akan bekerja pada hari itu.

Person alice = new Person( "Alice" );
Person bob = new Person( "Bob" );
Person carol = new Person( "Carol" );

Map.of()

Map.ofmenciptakan yang kosong Map. Tidak dapat dimodifikasi, sehingga Anda tidak dapat menambahkan entri. Berikut adalah contoh peta seperti itu, kosong tanpa entri.

Map < DayOfWeek, Person > dailyWorkerEmpty = Map.of();

dailyWorkerEmpty.toString (): {}

Map.of( … )

Map.of( k , v , k , v , …)ada beberapa metode yang mengambil 1 hingga 10 pasangan nilai kunci. Ini adalah contoh dari dua entri.

Map < DayOfWeek, Person > weekendWorker = 
        Map.of( 
            DayOfWeek.SATURDAY , alice ,     // key , value
            DayOfWeek.SUNDAY , bob           // key , value
        )
;

weekendWorker.toString (): {SUNDAY = Orang {name = 'Bob'}, SATURDAY = Orang {name = 'Alice'}}

Map.ofEntries( … )

Map.ofEntries( Map.Entry , … )mengambil sejumlah objek yang mengimplementasikan Map.Entryantarmuka. Java bundel dua kelas mengimplementasikan antarmuka itu, satu bisa berubah, yang lainnya tidak berubah: AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry. Tetapi kita tidak perlu menentukan kelas konkret. Kita hanya perlu memanggil Map.entry( k , v )metode, meneruskan kunci dan nilai kita, dan kita mendapatkan kembali objek dari beberapa Map.Entryantarmuka implementasi kelas .

Map < DayOfWeek, Person > weekdayWorker = Map.ofEntries(
        Map.entry( DayOfWeek.MONDAY , alice ) ,            // Call to `Map.entry` method returns an object implementing `Map.Entry`. 
        Map.entry( DayOfWeek.TUESDAY , bob ) ,
        Map.entry( DayOfWeek.WEDNESDAY , bob ) ,
        Map.entry( DayOfWeek.THURSDAY , carol ) ,
        Map.entry( DayOfWeek.FRIDAY , carol )
);

weekdayWorker.toString (): {WEDNESDAY = Orang {name = 'Bob'}, SELASA = Orang {name = 'Bob'}, KAMIS = Orang {name = 'Carol'}, FRIDAY = Orang {nama = 'Carol'} , SENIN = Orang {name = 'Alice'}}

Map.copyOf

Java 10 menambahkan metode ini Map.copyOf. Lewati peta yang ada, dapatkan kembali salinan peta itu yang tidak berubah.

Catatan

Perhatikan bahwa urutan iterator peta yang dihasilkan melalui Map.ofyang tidak dijamin. Entri memiliki perintah sewenang-wenang. Jangan menulis kode berdasarkan urutan yang terlihat, karena dokumentasi memperingatkan pesanan dapat berubah.

Perhatikan bahwa semua Map.of…metode ini mengembalikan a Mapdari kelas yang tidak ditentukan . Kelas beton yang mendasari bahkan dapat bervariasi dari satu versi Java ke yang lain. Anonimitas ini memungkinkan Java untuk memilih dari berbagai implementasi, apa pun yang secara optimal sesuai dengan data khusus Anda. Misalnya, jika kunci Anda berasal dari enum , Java mungkin menggunakan EnumMapbawah.

Anda dapat membuat Map.ofmetode Anda sendiri (yang hanya tersedia di Java 9 dan lebih tinggi) dengan mudah dalam 2 cara mudah

Buat dengan sejumlah parameter yang ditetapkan

Contoh

public <K,V> Map<K,V> mapOf(K k1, V v1, K k2, V v2 /* perhaps more parameters */) {
    return new HashMap<K, V>() {{
      put(k1, v1);
      put(k2,  v2);
      // etc...
    }};
}

Jadikan menggunakan Daftar

Anda juga dapat membuatnya menggunakan daftar, alih-alih membuat banyak metode untuk serangkaian parameter tertentu.

Contoh

public <K, V> Map<K, V> mapOf(List<K> keys, List<V> values) {
   if(keys.size() != values.size()) {
        throw new IndexOutOfBoundsException("amount of keys and values is not equal");
    }

    return new HashMap<K, V>() {{
        IntStream.range(0, keys.size()).forEach(index -> put(keys.get(index), values.get(index)));
    }};
}

Catatan Tidak disarankan untuk menggunakan ini untuk semuanya karena ini membuat kelas anonim setiap kali Anda menggunakan ini.

JAWA 8

Di java 8 Anda juga memiliki kemungkinan menggunakan Streams/Collectorsuntuk melakukan pekerjaan.

Map<String, String> myMap = Stream.of(
         new SimpleEntry<>("key1", "value1"),
         new SimpleEntry<>("key2", "value2"),
         new SimpleEntry<>("key3", "value3"))
        .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue));

Ini memiliki keuntungan karena tidak membuat kelas Anonim.

Perhatikan bahwa impor adalah:

import static java.util.stream.Collectors.toMap;
import java.util.AbstractMap.SimpleEntry;

Tentu saja, seperti disebutkan dalam jawaban lain, di java 9 dan seterusnya Anda memiliki cara yang lebih sederhana untuk melakukan hal yang sama.

Sayangnya, menggunakan varargs jika jenis kunci dan nilai tidak sama tidak masuk akal karena Anda harus menggunakan Object...dan kehilangan keamanan jenis sepenuhnya. Jika Anda selalu ingin membuat misalnya a Map<String, String>, tentu saja atoMap(String... args) mungkin saja, tetapi tidak terlalu cantik karena akan mudah untuk mencampur kunci dan nilai, dan sejumlah ganjil argumen akan tidak valid.

Anda bisa membuat sub-kelas dari HashMap yang memiliki metode seperti rantai

public class ChainableMap<K, V> extends HashMap<K, V> {
  public ChainableMap<K, V> set(K k, V v) {
    put(k, v);
    return this;
  }
}

dan menggunakannya seperti new ChainableMap<String, Object>().set("a", 1).set("b", "foo")

Pendekatan lain adalah dengan menggunakan pola pembangun umum:

public class MapBuilder<K, V> {
  private Map<K, V> mMap = new HashMap<>();

  public MapBuilder<K, V> put(K k, V v) {
    mMap.put(k, v);
    return this;
  }

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

dan menggunakannya seperti new MapBuilder<String, Object>().put("a", 1).put("b", "foo").build();

Namun, solusi yang saya gunakan sekarang dan kemudian menggunakan varargs dan Pairkelas:

public class Maps {
  public static <K, V> Map<K, V> of(Pair<K, V>... pairs) {
    Map<K, V> = new HashMap<>();

    for (Pair<K, V> pair : pairs) {
      map.put(pair.first, pair.second);
    }

    return map;
  }
}

Map<String, Object> map = Maps.of(Pair.create("a", 1), Pair.create("b", "foo");

Kata-kata Pair.create()yang agak mengganggu saya sedikit, tetapi ini bekerja cukup baik. Jika Anda tidak keberatan impor statis, tentu saja Anda dapat membuat pembantu:

public <K, V> Pair<K, V> p(K k, V v) {
  return Pair.create(k, v);
}

Map<String, Object> map = Maps.of(p("a", 1), p("b", "foo");

(Alih-alih Pairbisa dibayangkan menggunakan Map.Entry, tapi karena itu antarmuka, ini membutuhkan kelas implementasi dan / atau metode pabrik pembantu. Ini juga tidak dapat diubah, dan mengandung logika lain yang tidak berguna untuk tugas ini.)

Anda dapat menggunakan Streams In Java 8 (ini adalah exmaple dari Set):

@Test
public void whenInitializeUnmodifiableSetWithDoubleBrace_containsElements() {
    Set<String> countries = Stream.of("India", "USSR", "USA")
      .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));

    assertTrue(countries.contains("India"));
}

Ref: https://www.baeldung.com/java-double-brace-initialisation

Jika Anda hanya perlu menempatkan satu pasangan nilai kunci, Anda dapat menggunakan Collections.singletonMap (kunci, nilai);