web-dev-qa-db-fra.com

ajout de plusieurs entrées à une carte de hachage en une seule fois

J'ai besoin d'initialiser une constante HashMap et je voudrais le faire en une seule déclaration. Éviter qc comme ceci:

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

semblable à ceci dans Objective 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 en ayant examiné un si grand nombre.

javaandroidiphonehashmapnsdictionary
104
user387184

Tu peux le faire:

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

Vous pouvez utiliser ImmutableMap de Google Guava. Cela fonctionne tant que vous ne vous souciez pas de modifier la carte ultérieurement (vous ne pouvez pas appeler .put () sur la carte après l'avoir construite avec 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 aussi: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ImmutableMap.html

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

54
JimmyT

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 voulez 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'assistance similaire ou d'utiliser une bibliothèque tierce (comme Guava ) pour ajouter cette fonctionnalité.

33
Timo Türschmann

Java n'a pas de littéral carte, il n'y a donc pas de bonne façon de faire exactement ce que vous demandez.

Si vous avez besoin de ce type de syntaxe, considérez Groovy, qui est compatible avec Java et vous permet de:

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

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 l'utiliser

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

Cela donne {a:1, b:2}

6
Dakusan

Des méthodes d'usine ont également été ajoutées aux cartes dans Java 9. Jusqu'à 10 entrées, les constructeurs surchargés capturent des paires de clés et de valeurs. Par exemple, nous pourrions créer une carte de différentes villes et de leurs populations (d'après Google en octobre 2016) comme suit:

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

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

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

Méthodes de collection Factory en Java 9

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

En ignorant la déclaration de x (nécessaire pour éviter un diagnostic "instruction inaccessible"), il ne s'agit techniquement que d'une déclaration.

5
Hot Licks

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 9, vous pouvez utiliser Map.of

1
R. Oosterholt

Une autre approche peut être d’écrire une fonction spéciale pour extraire toutes les valeurs d’éléments d’une chaîne par une 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;
    }
}
0
Uri Ziv