ajouter plusieurs entrées à un HashMap à la fois dans une seule instruction

J'ai besoin d'initialiser un HashMap constant et j'aimerais le faire en une seule ligne. Éviter qc comme ça:

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

similaire à celui de l'objectif C:

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

Je n'ai trouvé aucun exemple qui montre comment faire cela après en avoir examiné autant.

Tu peux le faire:

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

Vous pouvez utiliser ImmutableMap de Google Guava. Cela fonctionne tant que vous ne vous souciez pas de modifier la carte plus tard (vous ne pouvez pas appeler .put () sur la carte après l'avoir construite à l'aide de cette méthode):

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

Voir également: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableMap.html

Une question quelque peu liée: Solution de contournement ImmutableMap.of () pour HashMap dans Maps?

Depuis Java 9, il est possible d'utiliser Map.of(...), comme ceci:

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

Cette carte est immuable. Si vous souhaitez que la carte soit modifiable, vous devez ajouter:

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

Si vous ne pouvez pas utiliser Java 9, vous êtes obligé d'écrire vous-même une méthode d'aide similaire ou d'utiliser une bibliothèque tierce (comme Guava ) pour ajouter cette fonctionnalité pour vous.

Java n'a pas de littéral de carte, il n'y a donc pas de moyen agréable de faire exactement ce que vous demandez.

Si vous avez besoin de ce type de syntaxe, pensez à Groovy, qui est compatible Java et vous permet de faire:

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

Les cartes ont également eu des méthodes d'usine ajoutées dans Java 9. Pour jusqu'à 10 entrées, les cartes ont surchargé les constructeurs qui prennent des paires de clés et de valeurs. Par exemple, nous pourrions construire une carte de différentes villes et de leurs populations (selon google en octobre 2016) comme suit:

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

Le cas var-args pour Map est un peu plus difficile, vous devez avoir à la fois des clés et des valeurs, mais en Java, les méthodes ne peuvent pas avoir deux paramètres var-args. Le cas général est donc géré en prenant une méthode d' Map.Entry<K, V>objets var-args et en ajoutant une entry()méthode statique qui les construit. Par exemple:

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

Méthodes d'usine de collecte dans Java 9

Voici un cours simple qui accomplira ce que vous voulez

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

Et puis de l'utiliser

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

Cela donne {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;);

Ignorant la déclaration de x(qui est nécessaire pour éviter un diagnostic "instruction inaccessible"), techniquement, ce n'est qu'une instruction.

Vous pouvez ajouter cette fonction utilitaire à une classe utilitaire:

public static <K, V> Map<K, V> mapOf(Object... keyValues) {
    Map<K, V> map = new HashMap<>();

    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 = YourClass.mapOf(1, "value1", 2, "value2");
Map<String, String> map2 = YourClass.mapOf("key1", "value1", "key2", "value2");

Remarque: dans Java 9vous pouvez utiliser Map.of

Une autre approche peut consister à écrire une fonction spéciale pour extraire toutes les valeurs d'éléments d'une chaîne par expression régulière:

import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Example {
    public static void main (String[] args){
        HashMap<String,Integer> hashMapStringInteger = createHashMapStringIntegerInOneStat("'one' => '1', 'two' => '2' , 'three'=>'3'  ");

        System.out.println(hashMapStringInteger); // {one=1, two=2, three=3}
    }

    private static HashMap<String, Integer> createHashMapStringIntegerInOneStat(String str) {
        HashMap<String, Integer> returnVar = new HashMap<String, Integer>();

        String currentStr = str;
        Pattern pattern1 = Pattern.compile("^\\s*'([^']*)'\\s*=\\s*>\\s*'([^']*)'\\s*,?\\s*(.*)$");

        // Parse all elements in the given string.
        boolean thereIsMore = true;
        while (thereIsMore){
            Matcher matcher = pattern1.matcher(currentStr);
            if (matcher.find()) {
                returnVar.put(matcher.group(1),Integer.valueOf(matcher.group(2)));
                currentStr = matcher.group(3);
            }
            else{
                thereIsMore = false;
            }
        }

        // Validate that all elements in the given string were parsed properly
        if (currentStr.length() > 0){
            System.out.println("WARNING: Problematic string format. given String: " + str);
        }

        return returnVar;
    }
}