Wie initialisiere ich eine HashMap direkt (wörtlich)?

Gibt es eine Möglichkeit, eine Java HashMap so zu initialisieren ?:

Map test = new HashMap{"test":"test","test":"test"}; 

Was wäre die korrekte Syntax? Ich habe diesbezüglich nichts gefunden. Ist das möglich? Ich suche nach dem kürzesten / schnellsten Weg, um einige “final / static” -Werte in einer Karte zu setzen, die sich niemals ändern und im Voraus bekannt sind, wenn die Map erstellt wird.

   

    Nein, Sie müssen alle Elemente manuell hinzufügen. Sie können jedoch einen statischen Initialisierer verwenden:

     public class Demo { private static final Map myMap; static { myMap = new HashMap(); myMap.put("a", "b"); myMap.put("c", "d"); } } 

    Beachten Sie, dass die Verwendung einer function für die Initialisierung dasselbe bewirkt, jedoch die Lesbarkeit des Codes verbessert:

     public class Demo { private static final Map myMap = createMap(); private static Map createMap() { Map myMap = new HashMap(); myMap.put("a", "b"); myMap.put("c", "d"); return myMap; } } 

    Java 9

    In Java 9 wurden einige Factory-Methoden hinzugefügt, die auch die Erstellung von Maps vereinfachen können:

     public class Demo { private static final Map test = Map.of("a", "b", "c", "d"); private static final Map test2 = Map.ofEntries( entry("a", "b"), entry("c", "d") ); } 

    Im obigen Beispiel sind test2 und test2 identisch, nur mit verschiedenen Möglichkeiten, die Map auszudrücken. Die Map.of Methode ist für bis zu zehn Elemente in der Map definiert, während die Map.ofEntries Methode keine solche Beschränkung aufweist.

    Beachten Sie, dass in diesem Fall die resultierende Karte eine unveränderliche Karte ist. Wenn Sie möchten, dass die Karte änderbar ist, können Sie sie erneut kopieren, z. B. mit mutableMap = new HashMap<>(Map.of("a", "b"));

    (Siehe auch GEP 269 und das Javadoc )

    Dies ist ein Weg.

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

    Sie sollten jedoch vorsichtig sein und sicherstellen, dass Sie den obigen Code verstehen (er erstellt eine neue class, die von HashMap erbt). Daher sollten Sie hier mehr lesen: http://www.c2.com/cgi/wiki?DoubleBraceInitialization , oder einfach Guava verwenden:

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

    Wenn Sie Bibliotheken von Drittanbietern zulassen, können Sie Guava ‘ UnmutableMap verwenden , um eine wörtliche Kürze zu erreichen:

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

    Dies funktioniert für bis zu 5 Schlüssel / Wert-Paare , ansonsten können Sie den Builder verwenden :

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

    • Beachten Sie, dass die ImmutableMap- Implementierung von Guava sich von der HashMap- Implementierung von Java unterscheidet (vor allem ist sie unveränderlich und lässt keine Null-Schlüssel / Werte zu)
    • Weitere Informationen finden Sie im Guava-Benutzerhandbuch zu den unveränderlichen Sammlungsarten

    Es gibt keine direkte Möglichkeit, dies zu tun – Java hat keine Map-Literale (noch – ich denke, sie wurden für Java 8 vorgeschlagen).

    Manche Leute mögen das:

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

    Dadurch wird eine anonyme Unterklasse von HashMap erstellt, deren Instanzinitialisierer diese Werte ablegt. (Übrigens kann eine Map nicht doppelt so groß sein wie der zweite, sondern der zweite wird den ersten überschreiben. Für die nächsten Beispiele werde ich andere Werte verwenden.)

    Der normale Weg wäre dies (für eine lokale Variable):

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

    Wenn Ihre Testzuordnung eine Instanzvariable ist, legen Sie die Initialisierung in einen Konstruktor oder Instanzinitialisierer:

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

    Wenn Ihre Testzuordnung eine classnvariable ist, setzen Sie die Initialisierung in einen statischen Initialisierer:

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

    Wenn Sie möchten, dass sich Ihre Map niemals ändert, sollten Sie nach der Initialisierung Ihre Map mit Collections.unmodifiableMap(...) umbrechen. Sie können dies auch in einem statischen Initialisierer tun:

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

    (Ich bin mir nicht sicher, ob Sie jetzt den test endgültig machen können … probieren Sie es aus und melden Sie es hier.)

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

    Eine Alternative mit einfachen Java 7-classn und varargs: Erstellen Sie eine class HashMapBuilder mit dieser Methode:

     public static HashMap build(String... data){ HashMap result = new HashMap(); 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; } 

    Verwenden Sie die Methode wie folgt:

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