Java Language
Kaarten

Invoering

Opmerkingen

Voeg een element toe

1. toevoeging

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element."); 
System.out.println(map.get(1));

Uitgang: First element.

2. override

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element.");
map.put(1, "New element.");
System.out.println(map.get(1));

Output: New element.

HashMap wordt als voorbeeld gebruikt. Andere implementaties die de uitvoering van Map -interface kan worden gebruikt als goed.

Voeg meerdere items toe

We kunnen V put(K key,V value) :

Associeert de opgegeven waarde met de opgegeven sleutel in deze kaart (optionele bewerking). Als de kaart eerder een toewijzing voor de sleutel bevatte, wordt de oude waarde vervangen door de opgegeven waarde.

String currentVal;
Map<Integer, String> map = new TreeMap<>();
currentVal = map.put(1, "First element.");
System.out.println(currentVal);// Will print null
currentVal = map.put(2, "Second element.");
System.out.println(currentVal); // Will print null yet again    
currentVal = map.put(2, "This will replace 'Second element'");
System.out.println(currentVal); // will print Second element.
System.out.println(map.size()); // Will print 2 as key having
// value 2 was replaced.

Map<Integer, String> map2 = new HashMap<>();
map2.put(2, "Element 2");
map2.put(3, "Element 3");

map.putAll(map2);

System.out.println(map.size());  

Output:

3

Om veel items toe te voegen, kunt u een innerlijke klasse zoals deze gebruiken:

Map<Integer, String> map = new HashMap<>() {{
    // This is now an anonymous inner class with an unnamed instance constructor
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}};

Houd er rekening mee dat het creëren van een anonieme binnenklasse niet altijd efficiënt is en tot geheugenlekken kan leiden. Gebruik daarom indien mogelijk een initialisatieblok:

static Map<Integer, String> map = new HashMap<>();

static {
    // Now no inner classes are created so we can avoid memory leaks
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}

In het bovenstaande voorbeeld wordt de kaart statisch. Het kan ook worden gebruikt in een niet-statische context door alle gevallen van static elektriciteit te verwijderen.

Bovendien ondersteunen de meeste implementaties putAll , waarmee alle vermeldingen in de ene map als volgt aan de andere kunnen worden toegevoegd:

another.putAll(one);

Standaardmethoden van Map uit Java gebruiken 8

Voorbeelden van het gebruik van standaardmethoden geïntroduceerd in Java 8 in de kaartinterface

1. GetOrDefault gebruiken

Retourneert de waarde die is toegewezen aan de sleutel of retourneert de standaardwaarde als de sleutel niet aanwezig is

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element");
map.get(1);                                 // => First element
map.get(2);                                 // => null
map.getOrDefault(2, "Default element");     // => Default element

2. ForEach gebruiken

Hiermee kan de bewerking worden uitgevoerd die is gespecificeerd in de 'actie' op elk kaartitem

  Map<Integer, String> map = new HashMap<Integer, String>();
  map.put(1, "one");
  map.put(2, "two");
  map.put(3, "three");
  map.forEach((key, value) -> System.out.println("Key: "+key+ " :: Value: "+value));

   // Key: 1 :: Value: one
   // Key: 2 :: Value: two
   // Key: 3 :: Value: three

3. Alles vervangen gebruiken

Wordt alleen vervangen door een nieuwe waarde als de sleutel aanwezig is

 Map<String, Integer> map = new HashMap<String, Integer>();
 map.put("john", 20);
 map.put("paul", 30);
 map.put("peter", 40);
 map.replaceAll((key,value)->value+10);   //{john=30, paul=40, peter=50}

4. PutIfAbsent gebruiken

Sleutel / waarde-paar wordt aan de kaart toegevoegd als de sleutel niet aanwezig is of aan nul is toegewezen

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.putIfAbsent("kelly", 50);     //{john=20, paul=30, peter=40, kelly=50}

5. Verwijderen gebruiken

   Verwijdert de sleutel alleen als deze is gekoppeld aan de opgegeven waarde

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.remove("peter",40); //{john=30, paul=40}
   

6. Gebruik vervangen

   Als de sleutel aanwezig is, wordt de waarde vervangen door een nieuwe waarde. Als de sleutel niet aanwezig is, doet niets.

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.replace("peter",50); //{john=20, paul=30, peter=50}
map.replace("jack",60); //{john=20, paul=30, peter=50}

7. ComputeIfAbsent gebruiken

Deze methode voegt een vermelding toe aan de kaart. de sleutel wordt opgegeven in de functie en de waarde is het resultaat van de toepassing van de toewijzingsfunctie

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfAbsent("kelly", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30}
    map.computeIfAbsent("peter", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30} //peter already present

8. ComputeIfPresent gebruiken

Deze methode voegt een invoer toe of wijzigt een bestaande invoer in de kaart. Doet niets als een invoer met die sleutel niet aanwezig is

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfPresent("kelly", (k,v)->v+10); //{john=20, paul=30, peter=40} //kelly not present
    map.computeIfPresent("peter", (k,v)->v+10); //{john=20, paul=30, peter=50} // peter present, so increase the value 

9. Compute gebruiken

Deze methode vervangt de waarde van een sleutel door de nieuw berekende waarde

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.compute("peter", (k,v)->v+50); //{john=20, paul=30, peter=90} //Increase the value 

10. Samenvoegen gebruiken

Voegt het sleutel / waarde-paar toe aan de kaart, als de sleutel niet aanwezig is of de waarde voor de sleutel nul is. Vervangt de waarde door de nieuw berekende waarde, als de sleutel aanwezig is. Sleutel wordt van de kaart verwijderd, als de nieuwe berekende waarde nul is.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    
    //Adds the key-value pair to the map, if key is not present or value for the key is null
    map.merge("kelly", 50 , (k,v)->map.get("john")+10); // {john=20, paul=30, peter=40, kelly=50}
    
    //Replaces the value with the newly computed value, if the key is present
    map.merge("peter", 50 , (k,v)->map.get("john")+10); //{john=20, paul=30, peter=30, kelly=50}
   
    //Key is removed from the map , if new value computed is null
    map.merge("peter", 30 , (k,v)->map.get("nancy")); //{john=20, paul=30, kelly=50}

Wis de kaart

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

map.put(1, "First element.");
map.put(2, "Second element.");
map.put(3, "Third element.");

map.clear();

System.out.println(map.size());   // => 0

Door de inhoud van een kaart bladeren

Kaarten bieden methoden waarmee u de collecties, waarden of sleutel / waarde-paren van de kaart als collecties kunt gebruiken. U kunt door deze collecties bladeren. Gegeven de volgende kaart bijvoorbeeld:

Map<String, Integer> repMap = new HashMap<>();
repMap.put("Jon Skeet", 927_654);
repMap.put("BalusC", 708_826);
repMap.put("Darin Dimitrov", 715_567);

Door de kaarttoetsen bladeren:

for (String key : repMap.keySet()) {
    System.out.println(key);
}

prints:

Darin Dimitrov
Jon Skeet
BalusC

keySet() biedt de sleutels van de kaart als een Set . Set wordt gebruikt omdat de sleutels geen dubbele waarden kunnen bevatten. Door de set heen te bladeren krijgt elke toets op zijn beurt. HashMaps zijn niet besteld, dus in dit voorbeeld kunnen de sleutels in elke volgorde worden geretourneerd.

Door kaartwaarden bladeren:

for (Integer value : repMap.values()) {
    System.out.println(value);
}

prints:

715.567
927.654
708.826

values() retourneert de waarden van de kaart als een Collection . Door de collectie heen bladeren, levert elke waarde op zijn beurt op. Nogmaals, de waarden kunnen in willekeurige volgorde worden geretourneerd.

Samen toetsen en waarden doornemen

for (Map.Entry<String, Integer> entry : repMap.entrySet()) {
    System.out.printf("%s = %d\n", entry.getKey(), entry.getValue());
}

prints:

Darin Dimitrov = 715567
Jon Skeet = 927654
BalusC = 708826

entrySet() retourneert een verzameling Map.Entry objecten. Map.Entry geeft toegang tot de sleutel en waarde voor elk item.

Kaarten samenvoegen, combineren en samenstellen

Gebruik putAll om elk lid van de ene kaart in een andere te plaatsen. Voor sleutels die al op de kaart aanwezig zijn, worden de bijbehorende waarden overschreven.

Map<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1)
numbers.put("Three", 3)
Map<String, Integer> other_numbers = new HashMap<>();
other_numbers.put("Two", 2)
other_numbers.put("Three", 4)

numbers.putAll(other_numbers)

Dit levert de volgende afbeelding in numbers :

"One" -> 1
"Two" -> 2
"Three" -> 4 //old value 3 was overwritten by new value 4

Als u waarden wilt combineren in plaats van ze te overschrijven, kunt u Map.merge , toegevoegd in Java 8, die een door de gebruiker geleverde BiFunction gebruikt om waarden voor dubbele sleutels samen te voegen. merge werkt op afzonderlijke sleutels en waarden, dus u moet een lus of Map.forEach . Hier voegen we strings samen voor dubbele sleutels:

for (Map.Entry<String, Integer> e : other_numbers.entrySet())
    numbers.merge(e.getKey(), e.getValue(), Integer::sum);
//or instead of the above loop
other_numbers.forEach((k, v) -> numbers.merge(k, v, Integer::sum));

Als u de beperking wilt afdwingen, zijn er geen dubbele sleutels, u kunt een samenvoegfunctie gebruiken die een AssertionError :

mapA.forEach((k, v) ->
    mapB.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

Stel kaart <X, Y> en kaart <Y, Z> samen om kaart <X, Z> te krijgen

Als u twee toewijzingen wilt samenstellen, kunt u dit als volgt doen

    Map<String, Integer> map1 = new HashMap<String, Integer>();
    map1.put("key1", 1);
    map1.put("key2", 2);
    map1.put("key3", 3);
    
    Map<Integer, Double> map2 = new HashMap<Integer, Double>();
    map2.put(1, 1.0);
    map2.put(2, 2.0);
    map2.put(3, 3.0);

    Map<String, Double> map3 = new new HashMap<String, Double>();
    map1.forEach((key,value)->map3.put(key,map2.get(value)));

Dit levert de volgende afbeelding op

    "key1" -> 1.0
    "key2" -> 2.0
    "key3" -> 3.0

Controleer of de sleutel bestaat

Map<String, String> num = new HashMap<>();
num.put("one", "first");

if (num.containsKey("one")) {
    System.out.println(num.get("one")); // => first
}

Kaarten kunnen nulwaarden bevatten

Voor kaarten moet men voorzichtig zijn om "met een sleutel" niet te verwarren met "met een waarde". HashMap s kan bijvoorbeeld null bevatten, wat betekent dat het volgende volkomen normaal gedrag is:

Map<String, String> map = new HashMap<>();
map.put("one", null);
if (map.containsKey("one")) {
    System.out.println("This prints !"); // This line is reached 
}
if (map.get("one") != null) {
    System.out.println("This is never reached !"); // This line is never reached 
}

Meer formeel is er geen garantie dat map.contains(key) <=> map.get(key)!=null

Kaartinvoer efficiënt herhalen

Deze sectie biedt code en benchmarks voor tien unieke voorbeeldimplementaties die de invoer van een Map<Integer, Integer> herhalen en de som van de Integer getallen genereren. Alle voorbeelden hebben een algoritmische complexiteit van Θ(n) , maar de benchmarks zijn nog steeds nuttig om inzicht te geven welke implementaties efficiënter zijn in een "echte" omgeving.

1. Implementatie met Iterator met Map.Entry

    Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<Integer, Integer> pair = it.next();
        sum += pair.getKey() + pair.getValue();
    }

2. Implementatie met for met Map.Entry

    for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
        sum += pair.getKey() + pair.getValue();
    }

3. Implementatie met Map.forEach (Java 8+)

    map.forEach((k, v) -> sum[0] += k + v);

4. Implementatie met Map.keySet met for

    for (Integer key : map.keySet()) {
        sum += key + map.get(key);
    }

5. Implementatie met Map.keySet met Iterator

    Iterator<Integer> it = map.keySet().iterator();
    while (it.hasNext()) {
        Integer key = it.next();
        sum += key + map.get(key);
    }

6. Implementatie met for met Iterator en Map.Entry

    for (Iterator<Map.Entry<Integer, Integer>> entries = 
             map.entrySet().iterator(); entries.hasNext(); ) {
        Map.Entry<Integer, Integer> entry = entries.next();
        sum += entry.getKey() + entry.getValue();
    }

7. Implementatie met Stream.forEach (Java 8+)

    map.entrySet().stream().forEach(e -> sum += e.getKey() + e.getValue());

8. Implementatie met Stream.forEach met Stream.parallel (Java 8+)

    map.entrySet()
       .stream()
       .parallel()
       .forEach(e -> sum += e.getKey() + e.getValue());

9. Implementatie met IterableMap van Apache Collections

    MapIterator<Integer, Integer> mit = iterableMap.mapIterator();
    while (mit.hasNext()) {
        sum += mit.next() + it.getValue();
    }

10. Implementatie met behulp van MutableMap van Eclipse Collections

     mutableMap.forEachKeyValue((key, value) -> {
         sum += key + value;
     });

Prestatietests ( code beschikbaar op Github )
Testomgeving: Windows 8.1 64-bit, Intel i7-4790 3,60 GHz, 16 GB

1. Gemiddelde prestatie van 10 proeven (100 elementen) Best: 308 ± 21 ns / op

   Benchmark                           Score     Error  Units
   test3_UsingForEachAndJava8            308  ±     21  ns/op
   test10_UsingEclipseMutableMap         309  ±      9  ns/op
   test1_UsingWhileAndMapEntry           380  ±     14  ns/op
   test6_UsingForAndIterator             387  ±     16  ns/op
   test2_UsingForEachAndMapEntry         391  ±     23  ns/op
   test7_UsingJava8StreamAPI             510  ±     14  ns/op
   test9_UsingApacheIterableMap          524  ±      8  ns/op
   test4_UsingKeySetAndForEach           816  ±     26  ns/op
   test5_UsingKeySetAndIterator          863  ±     25  ns/op
   test8_UsingJava8StreamAPIParallel    5552  ±    185  ns/op
   

2. Gemiddelde prestaties van 10 proeven (10000 elementen) Best: 37.606 ± 0.790 μs / op

   Benchmark                           Score     Error  Units
   test10_UsingEclipseMutableMap       37606  ±    790  ns/op
   test3_UsingForEachAndJava8          50368  ±    887  ns/op
   test6_UsingForAndIterator           50332  ±    507  ns/op
   test2_UsingForEachAndMapEntry       51406  ±   1032  ns/op
   test1_UsingWhileAndMapEntry         52538  ±   2431  ns/op
   test7_UsingJava8StreamAPI           54464  ±    712  ns/op
   test4_UsingKeySetAndForEach         79016  ±  25345  ns/op
   test5_UsingKeySetAndIterator        91105  ±  10220  ns/op
   test8_UsingJava8StreamAPIParallel  112511  ±    365  ns/op
   test9_UsingApacheIterableMap       125714  ±   1935  ns/op
   

3. Gemiddelde prestaties van 10 proeven (100000 elementen) Best: 1184.767 ± 332.968 μs / op

   Benchmark                            Score       Error  Units
   test1_UsingWhileAndMapEntry       1184.767  ±  332.968  μs/op
   test10_UsingEclipseMutableMap     1191.735  ±  304.273  μs/op
   test2_UsingForEachAndMapEntry     1205.815  ±  366.043  μs/op
   test6_UsingForAndIterator         1206.873  ±  367.272  μs/op
   test8_UsingJava8StreamAPIParallel 1485.895  ±  233.143  μs/op
   test5_UsingKeySetAndIterator      1540.281  ±  357.497  μs/op
   test4_UsingKeySetAndForEach       1593.342  ±  294.417  μs/op
   test3_UsingForEachAndJava8        1666.296  ±  126.443  μs/op
   test7_UsingJava8StreamAPI         1706.676  ±  436.867  μs/op
   test9_UsingApacheIterableMap      3289.866  ± 1445.564  μs/op
   

4. Een vergelijking van prestatievariaties ten opzichte van de kaartgrootte

       x: Size of Map
    f(x): Benchmark Score (μs/op)

                 100      600     1100     1600     2100
        ---------------------------------------------------
        10  |   0.333    1.631    2.752    5.937    8.024
         3  |   0.309    1.971    4.147    8.147   10.473
         6  |   0.372    2.190    4.470    8.322   10.531
         1  |   0.405    2.237    4.616    8.645   10.707
Tests    2  |   0.376    2.267    4.809    8.403   10.910
 f(x)    7  |   0.473    2.448    5.668    9.790   12.125
         9  |   0.565    2.830    5.952    13.22   16.965
         4  |   0.808    5.012    8.813    13.939  17.407
         5  |   0.81     5.104    8.533    14.064  17.422
         8  |   5.173   12.499   17.351    24.671  30.403

Gebruik een aangepast object als sleutel

Voordat u uw eigen object als sleutel gebruikt, moet u de hashCode () en equals () methode van uw object overschrijven.

In eenvoudig geval zou je zoiets hebben als:

class MyKey {
    private String name;
    MyKey(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {            
        if(obj instanceof MyKey) {
            return this.name.equals(((MyKey)obj).name);
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

hashCode zal beslissen tot welke hash-emmer de sleutel behoort en equals zal beslissen welk object in die hash-emmer.

Zonder deze methode wordt de referentie van uw object gebruikt voor bovenstaande vergelijking, wat niet werkt tenzij u elke keer dezelfde objectreferentie gebruikt.

Gebruik van HashMap

HashMap is een implementatie van de kaartinterface die een gegevensstructuur biedt om gegevens op te slaan in sleutel / waarde-paren.

1. HashMap verklaren

Map<KeyType, ValueType> myMap = new HashMap<KeyType, ValueType>();

KeyType en ValueType moeten geldige typen in Java zijn, zoals - String, Integer, Float of elke aangepaste klasse zoals Werknemer, Student enz.

Bijvoorbeeld: Map<String,Integer> myMap = new HashMap<String,Integer>();

2. Waarden in HashMap zetten.

Om een waarde in de HashMap te plaatsen, moeten we de put methode aanroepen op het HashMap-object door de sleutel en de waarde als parameters door te geven.

myMap.put("key1", 1);
myMap.put("key2", 2);

Als u de put-methode aanroept met de sleutel die al in de kaart bestaat, zal de methode de waarde overschrijven en de oude waarde retourneren.

3. Waarden verkrijgen van HashMap.

Om de waarde van een HashMap te krijgen, moet u de methode get aanroepen door de sleutel als parameter door te geven.

myMap.get("key1");    //return 1 (class Integer)

Als u een sleutel doorgeeft die niet bestaat in de HashMap, retourneert deze methode null

4. Controleer of de sleutel in de kaart staat of niet.

myMap.containsKey(varKey);

5. Controleer of de waarde op de kaart staat of niet.

myMap.containsValue(varValue);

De bovenstaande methoden retourneren een boolean waarde waar of onwaar als sleutel, waarde bestaat in de kaart of niet.

Kaarten maken en initialiseren

Invoering

Maps slaan sleutel / waarde-paren op, waarbij elke sleutel een bijbehorende waarde heeft. Gegeven een bepaalde sleutel, kan de kaart de bijbehorende waarde zeer snel opzoeken.

Maps , ook bekend als associate array, is een object dat de gegevens opslaat in de vorm van sleutels en waarden. In Java worden kaarten weergegeven met behulp van de kaartinterface die geen uitbreiding is van de verzamelinginterface.

• Manier 1: -

   /*J2SE < 5.0*/
   Map map = new HashMap();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• Manier 2: -

   /*J2SE 5.0+ style (use of generics):*/
   Map<String, Object> map = new HashMap<>();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• Manier 3: -

    Map<String, Object> map = new HashMap<String, Object>(){{
        put("name", "A");
        put("address", "Malviya-Nagar");
        put("city", "Jaipur");
    }};
    System.out.println(map);
  

• Manier 4: -

    Map<String, Object> map = new TreeMap<String, Object>();
        map.put("name", "A");
        map.put("address", "Malviya-Nagar");
        map.put("city", "Jaipur");
    System.out.println(map);
  

• Manier 5: -

    //Java 8
    final Map<String, String> map =
        Arrays.stream(new String[][] {
            { "name", "A" }, 
            { "address", "Malviya-Nagar" }, 
            { "city", "jaipur" },
        }).collect(Collectors.toMap(m -> m[0], m -> m[1]));
    System.out.println(map);
  

• Manier 6: -

    //This way for initial a map in outside the function
    final static Map<String, String> map;
    static
    {
        map = new HashMap<String, String>();
        map.put("a", "b");
        map.put("c", "d");
    }
  

• Manier 7: - Een onveranderlijke kaart met één sleutel / waarde maken.

      //Immutable single key-value map
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
  

  Merk op dat het onmogelijk is om een dergelijke kaart te wijzigen .

  Elke poging om de kaart te wijzigen, resulteert in het gooien van de UnsupportedOperationException.

      //Immutable single key-value pair
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
      singletonMap.put("newKey", "newValue"); //will throw UnsupportedOperationException
      singletonMap.putAll(new HashMap<>()); //will throw UnsupportedOperationException
      singletonMap.remove("key"); //will throw UnsupportedOperationException
      singletonMap.replace("key", "value", "newValue"); //will throw UnsupportedOperationException
      //and etc