gleichzeitiges Hinzufügen mehrerer Einträge zu einer HashMap in einer Anweisung

Ich muss eine konstante HashMap initialisieren und möchte dies in einer einzeiligen Anweisung tun. So vermeiden:

  hashMap.put("One", new Integer(1)); // adding value into HashMap
  hashMap.put("Two", new Integer(2));      
  hashMap.put("Three", new Integer(3));

ähnlich wie bei Ziel C:

[NSDictionary dictionaryWithObjectsAndKeys:
@"w",[NSNumber numberWithInt:1],
@"K",[NSNumber numberWithInt:2],
@"e",[NSNumber numberWithInt:4],
@"z",[NSNumber numberWithInt:5],
@"l",[NSNumber numberWithInt:6],
nil] 

Ich habe kein Beispiel gefunden, das zeigt, wie das geht, nachdem ich mir so viele angesehen habe.

Du kannst den … benutzen Doppelte geschweifte Initialisierung Wie nachfolgend dargestellt:

Map<String, Integer> hashMap = new HashMap<String, Integer>()
{{
     put("One", 1);
     put("Two", 2);
     put("Three", 3);
}};

Als Warnung lesen Sie bitte den Thread Efficiency of Java „Double Brace Initialization“ für die Auswirkungen auf die Leistung, die dies haben könnte.

Seit Java 9 ist die Nutzung möglich Map.of(...)so:

Map<String, Integer> immutableMap = Map.of("One", 1, 
                                           "Two", 2, 
                                           "Three", 3);

Diese Karte ist unveränderlich. Wenn Sie möchten, dass die Karte veränderbar ist, müssen Sie Folgendes hinzufügen:

Map<String, Integer> hashMap = new HashMap<>(immutableMap);

Wenn Sie Java 9 nicht verwenden können, müssen Sie selbst eine ähnliche Hilfsmethode schreiben oder eine Bibliothek eines Drittanbieters (z Guave), um diese Funktionalität für Sie hinzuzufügen.

Sie können die ImmutableMap von Google Guava verwenden. Dies funktioniert, solange Sie sich nicht darum kümmern, die Karte später zu ändern (Sie können .put() nicht auf der Karte aufrufen, nachdem Sie sie mit dieser Methode erstellt haben):

import com.google.common.collect.ImmutableMap;

// For up to five entries, use .of()
Map<String, Integer> littleMap = ImmutableMap.of(
    "One", Integer.valueOf(1),
    "Two", Integer.valueOf(2),
    "Three", Integer.valueOf(3)
);

// For more than five entries, use .builder()
Map<String, Integer> bigMap = ImmutableMap.<String, Integer>builder()
    .put("One", Integer.valueOf(1))
    .put("Two", Integer.valueOf(2))
    .put("Three", Integer.valueOf(3))
    .put("Four", Integer.valueOf(4))
    .put("Five", Integer.valueOf(5))
    .put("Six", Integer.valueOf(6))
    .build();

Siehe auch: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableMap.html

Eine etwas verwandte Frage: ImmutableMap.of() Workaround für HashMap in Maps?

Zu Maps wurden in Java 9 auch Factory-Methoden hinzugefügt. Für bis zu 10 Einträge haben Maps überladene Konstruktoren, die Paare von Schlüsseln und Werten annehmen. Zum Beispiel könnten wir eine Karte verschiedener Städte und ihrer Bevölkerung (laut Google im Oktober 2016) wie folgt erstellen:

Map<String, Integer> cities = Map.of("Brussels", 1_139000, "Cardiff", 341_000);

Der var-args-Fall für Map ist etwas schwieriger, Sie müssen sowohl Schlüssel als auch Werte haben, aber in Java können Methoden nicht zwei var-args-Parameter haben. Der allgemeine Fall wird also behandelt, indem eine var-args-Methode von verwendet wird Map.Entry<K, V> Objekte und Hinzufügen einer statischen entry() Methode, die sie konstruiert. Zum Beispiel:

Map<String, Integer> cities = Map.ofEntries(
    entry("Brussels", 1139000), 
    entry("Cardiff", 341000)
);

Collection-Factory-Methoden in Java 9

Java hat kein Kartenliteral, daher gibt es keine nette Möglichkeit, genau das zu tun, was Sie fragen.

Wenn Sie diese Art von Syntax benötigen, ziehen Sie etwas Groovy in Betracht, das Java-kompatibel ist und Sie Folgendes tun lässt:

def map = [name:"Gromit", likes:"cheese", id:1234]

Hier ist eine einfache Klasse, die das erreicht, was Sie wollen

import java.util.HashMap;

public class QuickHash extends HashMap<String,String> {
    public QuickHash(String...KeyValuePairs) {
        super(KeyValuePairs.length/2);
        for(int i=0;i<KeyValuePairs.length;i+=2)
            put(KeyValuePairs[i], KeyValuePairs[i+1]);
    }
}

Und es dann zu benutzen

Map<String, String> Foo=QuickHash(
    "a", "1",
    "b", "2"
);

Dies ergibt {a:1, b:2}

    boolean x;
    for (x = false, 
        map.put("One", new Integer(1)), 
        map.put("Two", new Integer(2)),      
        map.put("Three", new Integer(3)); x;);

Ignorieren der Deklaration von x (was notwendig ist, um eine “unreachable statement”-Diagnose zu vermeiden), technisch gesehen ist es nur eine Anweisung.