aggiungendo più voci a una HashMap contemporaneamente in una sola istruzione

Devo inizializzare una HashMap costante e vorrei farlo in una riga. Evitando sth in questo modo:

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

simile a questo nell'obiettivo C:

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

Non ho trovato alcun esempio che mostri come farlo dopo averne visto così tanti.

Puoi farlo:

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

Puoi utilizzare ImmutableMap di Google Guava. Funziona finché non ti interessa modificare la mappa in un secondo momento (non puoi chiamare .put () sulla mappa dopo averla costruita usando questo metodo):

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

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

Una domanda in qualche modo correlata: Soluzione alternativa a ImmutableMap.of () per HashMap in Maps?

Da Java 9, è possibile utilizzare Map.of(...), in questo modo:

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

Questa mappa è immutabile. Se vuoi che la mappa sia mutabile, devi aggiungere:

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

Se non riesci a utilizzare Java 9, sei bloccato con la scrittura di un metodo di supporto simile o con una libreria di terze parti (come Guava ) per aggiungere quella funzionalità per te.

Java non ha una mappa letterale, quindi non c'è un bel modo di fare esattamente quello che stai chiedendo.

Se hai bisogno di quel tipo di sintassi, prendi in considerazione Groovy, che è compatibile con Java e ti consente di fare:

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

Le mappe hanno anche aggiunto metodi di fabbrica in Java 9. Per un massimo di 10 voci Le mappe hanno costruttori sovraccaricati che accettano coppie di chiavi e valori. Ad esempio, potremmo costruire una mappa delle varie città e delle loro popolazioni (secondo Google nell'ottobre 2016) come segue:

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

Il caso var-args per Map è un po 'più difficile, devi avere sia chiavi che valori, ma in Java i metodi non possono avere due parametri var-args. Quindi il caso generale viene gestito prendendo un metodo var-args di Map.Entry<K, V>oggetti e aggiungendo un entry()metodo statico che li costruisce. Per esempio:

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

Metodi di factory di raccolta in Java 9

Ecco una semplice classe che realizzerà ciò che desideri

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

E poi usarlo

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

Questo cede {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;);

Ignorando la dichiarazione di x(che è necessaria per evitare una diagnosi di "dichiarazione irraggiungibile"), tecnicamente è solo una frase.

È possibile aggiungere questa funzione di utilità a una classe di utilità:

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

Nota: in Java 9puoi usare Map.of

Un altro approccio potrebbe essere la scrittura di una funzione speciale per estrarre tutti i valori degli elementi da una stringa mediante un'espressione regolare:

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