Initialiseer een HashMap in Java

1. Overzicht

In deze tutorial leren we verschillende manieren om een Hash kaart in Java.

We gebruiken zowel Java 8 als Java 9.

2. De statische initialisator voor een statische Hash kaart

We kunnen een Hash kaart gebruik maken van een statisch blok code:

openbare statische kaart articleMapOne; statische {articleMapOne = nieuwe HashMap (); articleMapOne.put ("ar01", "Inleiding tot kaart"); articleMapOne.put ("ar02", "Een artikel"); }

Het voordeel van dit soort initialisatie is dat de map veranderlijk is, maar alleen statisch werkt. Bijgevolg kunnen vermeldingen worden toegevoegd en verwijderd wanneer dat nodig is.

Laten we doorgaan en het testen:

@Test openbare ongeldig gegevenStaticMap_whenUpdated_thenCorrect () {MapInitializer.articleMapOne.put ("NewArticle1", "Converteer array naar lijst"); assertEquals (MapInitializer.articleMapOne.get ("NewArticle1"), "Converteer array naar lijst"); }

We kunnen de kaart ook initialiseren met behulp van de syntaxis met dubbele accolades:

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

Let daar op we moeten proberen deze initialisatietechniek te vermijden, omdat het bij elk gebruik een anonieme extra klasse creëert, verborgen verwijzingen naar het omsluitende object bevat, en kan problemen met geheugenlekken veroorzaken.

3. Java-verzamelingen gebruiken

Als we een singleton-onveranderlijke kaart met een enkele invoer moeten maken, Collections.singletonMap () wordt erg handig:

openbare statische kaart createSingletonMap () {retourneer Collections.singletonMap ("gebruikersnaam1", "wachtwoord1"); }

Merk op dat de kaart hier onveranderlijk is, en als we proberen om meer items toe te voegen, zal hij gooien java.lang.UnsupportedOperationException.

We kunnen ook een onveranderlijke lege kaart maken met Collections.emptyMap ():

Map emptyMap = Collections.emptyMap ();

4. De Java 8 Way

Laten we in dit gedeelte kijken naar de manieren om een ​​kaart te initialiseren met Java 8 Stream API.

4.1. Gebruik makend van Collectors.toMap ()

Laten we een Stroom van een tweedimensionaal Draad array en verzamel ze in een kaart:

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

Let hier op het gegevenstype van de sleutel en de waarde van het Kaart is hetzelfde.

Laten we, om het algemener te maken, de reeks Voorwerpen en voer dezelfde bewerking uit:

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

Als resultaat maken we een kaart van de sleutel als een Draad en waarde als een Geheel getal.

4.2. Met behulp van een stream van Kaart

Hier gebruiken we de instanties van Kaart. Dit is een andere benadering waarbij we verschillende sleutel- en waardetypes hebben.

Laten we eerst gebruiken SimpleEntry implementatie van de Binnenkomst koppel:

Map map = Stream.of (nieuwe AbstractMap.SimpleEntry ("idee", 1), nieuwe AbstractMap.SimpleEntry ("mobiel", 2)) .collect (Collectors.toMap (Map.Entry :: getKey, Map.Entry :: getValue));

Laten we nu de kaart maken met SimpleImmutableEntry implementatie:

Map map = Stream.of (nieuwe AbstractMap.SimpleImmutableEntry ("idee", 1), nieuwe AbstractMap.SimpleImmutableEntry ("mobiel", 2)) .collect (Collectors.toMap (Map.Entry :: getKey, Map.Entry :: getValue));

4.3. Een onveranderlijke kaart initialiseren

In bepaalde gevallen moeten we een onveranderlijke kaart initialiseren. Dit kan worden gedaan door de Collectors.toMap () binnen 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));

Merk op dat we een dergelijke initialisatie moeten vermijden met Streams, omdat het een enorme prestatieoverhead kan veroorzaken en er worden veel afvalobjecten gemaakt om de kaart te initialiseren.

5. De Java 9 Way

Java 9 wordt geleverd met verschillende fabrieksmethoden in het Kaart interface die het maken en initialiseren van onveranderlijke kaarten vereenvoudigt.

Laten we doorgaan en deze fabrieksmethoden bekijken.

5.1. Kaart van()

Deze fabrieksmethode accepteert geen argument, een enkel argument en variabele argumenten:

Map emptyMap = Map.of (); Map singletonMap = Map.of ("key1", "value"); Map map = Map.of ("sleutel1", "waarde1", "sleutel2", "waarde2");

Houd er rekening mee dat deze methode maximaal 10 sleutel / waarde-paren ondersteunt.

5.2. Map.ofEntries ()

Het is vergelijkbaar met de Kaart van() maar heeft geen beperkingen voor het aantal sleutel / waarde-paren:

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

Merk op dat de fabrieksmethoden onveranderlijke kaarten produceren, dus elke mutatie zal resulteren in een UnsupportedOperationException.

Ze staan ​​ook geen null-sleutels of dubbele sleutels toe.

Als we nu een veranderlijke of groeiende kaart nodig hebben na initialisatie, kunnen we een van de implementaties van het Kaart interface en geef deze onveranderlijke kaarten door in de constructor:

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

6. Guava gebruiken

Terwijl we hebben gekeken naar de manieren om core Java te gebruiken, laten we doorgaan en een kaart initialiseren met behulp van de Guava-bibliotheek:

Mapartikelen = ImmutableMap.of ("Titel", "Mijn nieuwe artikel", "Titel2", "Tweede artikel");

Dit zou een onveranderlijke kaart creëren en een veranderlijke kaart creëren:

Kaartartikelen = Maps.newHashMap (ImmutableMap.of ("Titel", "Mijn nieuwe artikel", "Titel2", "Tweede artikel"));

De methode Onveranderlijke kaart. Van () heeft ook overbelaste versies die tot 5 paar sleutelwaardeparameters kunnen gebruiken. Hier is hoe een voorbeeld met 2 paar parameters eruit zou zien:

ImmutableMap.of ("sleutel1", "waarde1", "sleutel2", "waarde2");

7. Conclusie

In dit artikel hebben we de verschillende manieren onderzocht om een Kaart, in het bijzonder om lege, singleton, onveranderlijke en veranderlijke kaarten te maken. Zoals we kunnen zien, is er op dit gebied een enorme verbetering sinds Java 9.

Zoals altijd bevindt de voorbeeldbroncode zich in het Github-project. De Java 9-voorbeelden zijn hier te vinden en het Guava-voorbeeld hier.