Gibt es eine bewährte Methode zum Schreiben von Maps in Java?

Kurz gesagt, wenn Sie wollen, schreiben Sie eine Karte von z.B. Konstanten in Java, was z.B. in Python und Javascript, die Sie schreiben würde, als eine wörtliche,

T<String,String> CONSTANTS =
{
    "CONSTANT_NAME_0": CONSTANT_VALUE_0 ,
    "CONSTANT_NAME_1": CONSTANT_VALUE_1 ,
    "CONSTANT_NAME_2": CONSTANT_VALUE_2 ,
    //...
} ;

gibt es eine Class oder eine voreingestellte Object, die Sie verwenden können, für das schreiben eine Datenstruktur wie diese?

Kommentar zu dem Problem

Siehe auch initialisieren java HashSet Werte werden durch den Bau Frage. Kommentarautor: Ilia K.

InformationsquelleAutor der Frage FK82 | 2010-09-26

Konstanten? Ich würde verwenden eine enum.

public enum Constants { 
    NAME_1("Value1"),
    NAME_2("Value2"),
    NAME_3("Value3");

    private String value;

    Constants(String value) {
        this.value = value;
    }

    public String value() {
        return value;
    }
}

Wert für z.B. NAME_2 kann erhalten werden wie folgt:

String name2value = Constants.NAME_2.value();

Nur die enum ein bisschen mehr sinnvollen Namen, z.B. Settings, Defaults etc, was auch immer diese name/Wert-Paare eigentlich stellen.

InformationsquelleAutor der Antwort BalusC

47

Mag ich es so machen:
```
Map map = new HashMap() {{
    put("foo", "bar");
    put(123, 456);
}};
```
Den doppelten {{ }} eine Instanz-Initialisierung-block. Sie sind ein bisschen ungewöhnlich, aber Sie sind nützlich. Keine Notwendigkeit für Bibliotheken oder Hilfsprogramme.

InformationsquelleAutor der Antwort xpmatteo
33

Nein, Java muss nicht eine Karte literal. Der nächstgelegene Sie kommen werde, um mit Google Collections' ImmutableMap:
```
Map<K,V> CONSTANTS = ImmutableMap.of(
    NAME_1, VALUE_1,
    NAME_2, VALUE_2
    //etc.
  );
```
InformationsquelleAutor der Antwort Jorn

Sorry, ich bin ein Tüftler 🙂 Hier ist eine etwas sauberere Möglichkeit.

public class MapTest {
    private static Map<String, String> map;

    static {
        Map<String, String> tmpMap = new HashMap<String, String>();

        tmpMap.put("A", "Apple");
        tmpMap.put("B", "Banana");
        //etc
        map = Collections.unmodifiableMap(tmpMap);
    }

    public Map<String, String> getMap() {
        return map;
    }
}

InformationsquelleAutor der Antwort Tony Ennis

Können Sie schreiben, selbst eine schnelle-Helfer-Funktion:

@SuppressWarnings("unchecked")
public static <K,V> Map<K,V> ImmutableMap(Object... keyValPair){
    Map<K,V> map = new HashMap<K,V>();

    if(keyValPair.length % 2 != 0){
        throw new IllegalArgumentException("Keys and values must be pairs.");
    }

    for(int i = 0; i < keyValPair.length; i += 2){
        map.put((K) keyValPair[i], (V) keyValPair[i+1]);
    }

    return Collections.unmodifiableMap(map);
}

Hinweis: der code oben ist nicht zu stoppen, die Sie überschreiben Konstanten mit dem gleichen Namen, mit CONST_1 mehrere Orte in deiner Liste wird das Ergebnis in der letzten CONST_1's Wert erscheinen.

Nutzung ist so etwas wie:

Map<String,Double> constants = ImmutableMap(
    "CONST_0", 1.0,
    "CONST_1", 2.0
);

InformationsquelleAutor der Antwort Mark Elliot

Hier ist ein weiterer Weg, am besten geeignet für Karten, die nicht verändert werden:

public class Whatever {
    private static Map<String,String> map = new HashMap<String,String>();

    static {
        map.put("A", "Apple");
        map.put("B", "Banana");
        //etc
    }
}

InformationsquelleAutor der Antwort Tony Ennis

1

Java7 wohl zu implementieren, die folgende syntax:
```
Map<String, String> = {
    "key1": "value",
    "key2": "value",
    "key3": "value",
    "key4": "value"
};
```
Aber jetzt sind Sie gezwungen, Lösungen vorgeschlagen, von Jorn oder Tony Ennis.

InformationsquelleAutor der Antwort Crozin

Ok, mit Jorn ' s Verbesserung, die ich kann nicht scheinen, um die Karte wechseln zu alle, die intern oder extern. Vielleicht nicht ganz so gut lesbar, aber wenn Sie benötigen, um die Karte zu sein unmodifiable ich denke, das ist besser.

public class MapTest {
    private static Map<String, String> map = initMap();

    private static Map<String, String> initMap() {
        Map<String, String> map = new HashMap<String, String>();

        map.put("A", "Apple");
        map.put("B", "Banana");
        //etc
        return Collections.unmodifiableMap(map);
    }

    public Map<String, String> getMap() {
        return map;
    }

    public static void main(String[] args) {
        MapTest m = new MapTest();
        System.out.println(m.getMap().get("A"));
        m.getMap().put("this", "that");
    }
}

InformationsquelleAutor der Antwort Tony Ennis

Ich gerne die Deklaration und Initialisierung auf der gleichen Linie. Ich habe dieses handliche wenig Dienstprogramm so lange es im Grunde ist mein "anzeigen-literal" und bis Sie fertig sind "rechts" in der Sprache, ich werde weiter mit ihm so 🙂

Glücklich, es zu teilen hier.

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A handy utility for creating and initializing Maps in a single statement.
 * @author Jonathan Cobb. This source code is in the Public Domain.
 */
public class MapBuilder {

    /**
     * Most common create/init case. Usage:
     *
     *   Map<String, Boolean> myPremadeMap = MapBuilder.build(new Object[][]{
     *     { "a", true }, { "b", false }, { "c", true }, { "d", true },
     *     { "e", "yes, still dangerous but at least it's not an anonymous class" }
     *   });
     *
     * If your keys and values are of the same type, it will even be typesafe:
     *   Map<String, String> someProperties = MapBuilder.build(new String[][]{
     *       {"propA", "valueA" }, { "propB", "valueB" }
     *   });
     *
     * @param values [x][2] array. items at [x][0] are keys and [x][1] are values.
     * @return a LinkedHashMap (to preserve order of declaration) with the "values" mappings
     */
    public static <K,V> Map<K,V> build(Object[][] values) {
        return build(new LinkedHashMap<K,V>(), values);
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(new MyMapClass(options),
     *                                    new Object[][]{ {k,v}, {k,v}, ... });
     * @param map add key/value pairs to this map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Map<K,V> map, Object[][] values) {
        for (Object[] value : values) {
            map.put((K) value[0], (V) value[1]);
        }
        return map;
    }

    /** Same as above, for single-value maps */
    public static <K,V> Map<K,V> build(Map<K,V> map, K key, V value) {
        return build(map, new Object[][]{{key,value}});
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(MyMapClass.class, new Object[][]{ {k,v}, {k,v}, ... });
     * @param mapClass a Class that implements Map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Class<? extends Map<K,V>> mapClass, Object[][] values) {

        final Map<K,V> map;
        try { map = mapClass.newInstance(); } catch (Exception e) {
            throw new IllegalStateException("Couldn't create new instance of class: "+mapClass.getName(), e);
        }
        return build(map, values);
    }

    /** Usage: Map<K,V> myMap = MapBuilder.build(key, value); */
    public static <K,V> Map build(K key, V value) {
        Map<K,V> map = new HashMap<>();
        map.put(key, value);
        return map;
    }

}

InformationsquelleAutor der Antwort cobbzilla

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.