Inizializza una HashMap in Java

1. Panoramica

In questo tutorial, impareremo vari modi per inizializzare una HashMap in Java.

Useremo Java 8 e Java 9.

2. Lo Static Initializer per una Static HashMap

Possiamo inizializzare una HashMap usando un blocco di codice statico :

public static Map articleMapOne; static { articleMapOne = new HashMap(); articleMapOne.put("ar01", "Intro to Map"); articleMapOne.put("ar02", "Some article"); }

Il vantaggio di questo tipo di inizializzazione è che la mappa è modificabile, ma funzionerà solo per statica. Di conseguenza, le voci possono essere aggiunte e rimosse come e quando richiesto.

Andiamo avanti e proviamolo:

@Test public void givenStaticMap_whenUpdated_thenCorrect() { MapInitializer.articleMapOne.put( "NewArticle1", "Convert array to List"); assertEquals( MapInitializer.articleMapOne.get("NewArticle1"), "Convert array to List"); }

Possiamo anche inizializzare la mappa usando la sintassi delle doppie parentesi graffe:

Map doubleBraceMap = new HashMap() {{ put("key1", "value1"); put("key2", "value2"); }};

Si noti che dobbiamo cercare di evitare questa tecnica di inizializzazione perché crea una classe aggiuntiva anonima ad ogni utilizzo, contiene riferimenti nascosti all'oggetto che lo racchiude e potrebbe causare problemi di perdita di memoria.

3. Utilizzo delle raccolte Java

Se dobbiamo creare una mappa singleton immutabile con una singola voce, Collections.singletonMap () diventa molto utile:

public static Map createSingletonMap() { return Collections.singletonMap("username1", "password1"); }

Nota che la mappa qui è immutabile e se proviamo ad aggiungere più voci, verrà lanciata java.lang.UnsupportedOperationException.

Possiamo anche creare una mappa vuota immutabile usando Collections.emptyMap ():

Map emptyMap = Collections.emptyMap();

4. Il Java 8 Way

In questa sezione, esaminiamo i modi per inizializzare una mappa utilizzando Java 8 Stream API.

4.1. Utilizzo di Collectors.toMap ()

Usiamo un flusso di un array String bidimensionale e raccogliamo in una mappa:

Map map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, }).collect(Collectors.toMap(data -> data[0], data -> data[1]));

Notare che il tipo di dati della chiave e del valore della mappa è lo stesso.

Per renderlo più generico, prendiamo l'array di Oggetti ed eseguiamo la stessa operazione:

 Map map = Stream.of(new Object[][] { { "data1", 1 }, { "data2", 2 }, }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));

Di conseguenza, creiamo una mappa della chiave come String e il valore come Integer .

4.2. Utilizzo di un flusso di Map.Entry

Qui useremo le istanze di Map.Entry. Questo è un altro approccio in cui abbiamo diversi tipi di chiave e valore.

Innanzitutto, utilizziamo l' implementazione SimpleEntry dell'interfaccia Entry :

Map map = Stream.of( new AbstractMap.SimpleEntry("idea", 1), new AbstractMap.SimpleEntry("mobile", 2)) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Ora creiamo la mappa utilizzando l' implementazione SimpleImmutableEntry :

Map map = Stream.of( new AbstractMap.SimpleImmutableEntry("idea", 1), new AbstractMap.SimpleImmutableEntry("mobile", 2)) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

4.3. Inizializzazione di una mappa immutabile

In alcuni casi d'uso, è necessario inizializzare una mappa immutabile. Questo potrebbe essere fatto avvolgendo Collectors.toMap () all'interno di Collectors.collectingAndThen () :

Map map = Stream.of(new String[][] { { "Hello", "World" }, { "John", "Doe" }, }).collect(Collectors.collectingAndThen( Collectors.toMap(data -> data[0], data -> data[1]), Collections:: unmodifiableMap));

Si noti che dovremmo evitare di utilizzare tale inizializzazione utilizzando Streams, poiché potrebbe causare un enorme sovraccarico delle prestazioni e molti oggetti spazzatura vengono creati solo per inizializzare la mappa.

5. Il Java 9 Way

Java 9 viene fornito con vari metodi di fabbrica nell'interfaccia Map che semplificano la creazione e l'inizializzazione di mappe immutabili.

Andiamo avanti e esaminiamo questi metodi di fabbrica.

5.1. Mappa di ()

Questo metodo factory non accetta argomenti, un singolo argomento e argomenti variabili:

Map emptyMap = Map.of(); Map singletonMap = Map.of("key1", "value"); Map map = Map.of("key1","value1", "key2", "value2");

Tieni presente che questo metodo supporta solo un massimo di 10 coppie chiave-valore.

5.2. Map.ofEntries ()

È simile a Map.of () ma non ha limitazioni sul numero di coppie chiave-valore:

Map map = Map.ofEntries( new AbstractMap.SimpleEntry("name", "John"), new AbstractMap.SimpleEntry("city", "budapest"), new AbstractMap.SimpleEntry("zip", "000000"), new AbstractMap.SimpleEntry("home", "1231231231") );

Notare che i metodi factory producono mappe immutabili, quindi qualsiasi mutazione risulterà in un'eccezione UnsupportedOperationException.

Inoltre, non consentono chiavi nulle o chiavi duplicate.

Ora, se abbiamo bisogno di una mappa mutabile o in crescita dopo l'inizializzazione, possiamo creare una qualsiasi delle implementazioni dell'interfaccia Map e passare queste mappe immutabili nel costruttore:

Map map = new HashMap ( Map.of("key1","value1", "key2", "value2")); Map map2 = new HashMap ( Map.ofEntries( new AbstractMap.SimpleEntry("name", "John"), new AbstractMap.SimpleEntry("city", "budapest")));

6. Utilizzo di Guava

Dopo aver esaminato i modi di utilizzare Java di base, andiamo avanti e inizializziamo una mappa utilizzando la libreria Guava:

Map articles = ImmutableMap.of("Title", "My New Article", "Title2", "Second Article");

Questo creerebbe una mappa immutabile e per crearne una mutevole:

Map articles = Maps.newHashMap(ImmutableMap.of("Title", "My New Article", "Title2", "Second Article"));

Il metodo ImmutableMap.of () ha anche versioni sovraccaricate che possono richiedere fino a 5 coppie di parametri chiave-valore. Ecco come apparirebbe un esempio con 2 coppie di parametri:

ImmutableMap.of("key1", "value1", "key2", "value2");

7. Conclusione

In questo articolo abbiamo esplorato i vari modi di inizializzare una mappa , in particolare per creare mappe vuote, singole, immutabili e mutabili. Come possiamo vedere, c'è un enorme miglioramento in questo campo da Java 9.

Come sempre, il codice sorgente di esempio si trova nel progetto Github. Gli esempi Java 9 si trovano qui e l'esempio Guava qui.