Java Language
Karten

Einführung

Bemerkungen

Fügen Sie ein Element hinzu

1. Zusatz

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

Ausgabe: First element.

2. Überschreiben

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

Ausgabe: New element.

HashMap wird als Beispiel verwendet. Andere Implementierungen, die die Map Schnittstelle implementieren, können ebenfalls verwendet werden.

Fügen Sie mehrere Elemente hinzu

Wir können V put(K key,V value) :

Ordnet den angegebenen Wert in dieser Map dem angegebenen Schlüssel zu (optionale Operation). Wenn die Zuordnung zuvor eine Zuordnung für den Schlüssel enthielt, wird der alte Wert durch den angegebenen Wert ersetzt.

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

Ausgabe:

3

Um viele Elemente hinzuzufügen, können Sie eine innere Klasse wie folgt verwenden:

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

Beachten Sie, dass das Erstellen einer anonymen inneren Klasse nicht immer effizient ist und zu Speicherverlusten führen kann. Verwenden Sie daher, wenn möglich, einen Initialisierungsblock:

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

Das obige Beispiel macht die Karte statisch. Es kann auch in einem nicht statischen Kontext verwendet werden, indem alle static Vorkommnisse entfernt werden.

Darüber hinaus unterstützen die meisten Implementierungen putAll , mit dem alle Einträge in einer Map wie putAll werden können:

another.putAll(one);

Verwenden von Standardmethoden von Map aus Java 8

Beispiele für die Verwendung von in Java 8 in der Map-Schnittstelle eingeführten Standardmethoden

1. GetOrDefault verwenden

Gibt den dem Schlüssel zugeordneten Wert zurück. Wenn der Schlüssel nicht vorhanden ist, wird der Standardwert zurückgegeben

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 verwenden

Ermöglicht die Ausführung der in der "Aktion" für jeden Karteneintrag angegebenen Operation

  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. ReplaceAll verwenden

Wird nur durch einen neuen Wert ersetzt, wenn der Schlüssel vorhanden ist

 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 verwenden

Das Schlüssel-Wert-Paar wird der Karte hinzugefügt, wenn der Schlüssel nicht vorhanden ist oder auf Null gestellt wird

    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. Mit entfernen

   Entfernt den Schlüssel nur, wenn er mit dem angegebenen Wert verknüpft ist

    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. Verwenden Sie ersetzen

   Wenn der Schlüssel vorhanden ist, wird der Wert durch einen neuen Wert ersetzt. Wenn der Schlüssel nicht vorhanden ist, tut dies nichts.

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 verwenden

Diese Methode fügt einen Eintrag in der Map hinzu. Der Schlüssel wird in der Funktion angegeben und der Wert ist das Ergebnis der Anwendung der Mapping-Funktion

    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 verwenden

Diese Methode fügt einen Eintrag hinzu oder ändert einen vorhandenen Eintrag in der Map. Macht nichts, wenn ein Eintrag mit diesem Schlüssel nicht vorhanden ist

    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. Berechnen verwenden

Diese Methode ersetzt den Wert eines Schlüssels durch den neu berechneten Wert

    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. Merge verwenden

Fügt das Schlüssel-Wert-Paar zur Karte hinzu, wenn der Schlüssel nicht vorhanden ist oder der Wert für den Schlüssel Null ist. Ersetzt den Wert durch den neu berechneten Wert. Wenn der Schlüssel vorhanden ist, wird der Schlüssel aus der Karte entfernt, wenn der berechnete Wert Null ist

    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}

Karte löschen

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

Durchlaufen den Inhalt einer Map

Karten bieten Methoden, mit denen Sie auf die Schlüssel, Werte oder Schlüsselwertpaare der Karte als Sammlungen zugreifen können. Sie können diese Sammlungen durchlaufen. Zum Beispiel die folgende Karte:

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

Iteration durch Kartenschlüssel:

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

Drucke:

Darin Dimitrov
Jon Skeet
BalusC

keySet() stellt die Schlüssel der Karte als Set bereit. Set wird verwendet, da die Schlüssel keine doppelten Werte enthalten können. Durch das Durchlaufen des Satzes erhält man jede Taste. HashMaps werden nicht bestellt, daher können die Schlüssel in diesem Beispiel in beliebiger Reihenfolge zurückgegeben werden.

Durchlaufen von Kartenwerten:

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

Drucke:

715567
927654
708826

values() gibt die Werte der Map als Collection . Das Durchlaufen der Sammlung führt zu jedem Wert. Die Werte können auch in beliebiger Reihenfolge zurückgegeben werden.

Durchlaufen von Schlüsseln und Werten zusammen

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

Drucke:

Darin Dimitrov = 715567
Jon Skeet = 927654
BalusC = 708826

entrySet() gibt eine Auflistung von Map.Entry Objekten zurück. Map.Entry ermöglicht den Zugriff auf den Schlüssel und den Wert für jeden Eintrag.

Karten zusammenführen, kombinieren und komponieren

Verwenden Sie putAll , um jedes Mitglied einer Karte in eine andere zu setzen. Schlüssel, die bereits in der Karte vorhanden sind, werden mit den entsprechenden Werten überschrieben.

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)

Dies ergibt die folgende Zuordnung in numbers :

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

Wenn Sie Werte kombinieren möchten, anstatt sie zu überschreiben, können Sie Map.merge , das in Java 8 hinzugefügt wurde. In diesem Map.merge mithilfe einer vom Benutzer bereitgestellten BiFunction Werte für doppelte Schlüssel zusammengeführt. merge wirkt sich auf einzelne Schlüssel und Werte aus, daher müssen Sie eine Schleife oder Map.forEach . Hier verketten wir Strings für doppelte Schlüssel:

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

Wenn Sie die Einschränkung erzwingen möchten, gibt es keine doppelten Schlüssel. Sie können eine Zusammenführungsfunktion verwenden, die einen AssertionError :

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

Karte <X, Y> und Karte <Y, Z> erstellen, um Karte <X, Z> zu erhalten

Wenn Sie zwei Zuordnungen erstellen möchten, können Sie dies wie folgt tun

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

Dies ergibt die folgende Abbildung

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

Überprüfen Sie, ob der Schlüssel vorhanden ist

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

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

Karten können Nullwerte enthalten

Bei Karten muss man vorsichtig sein, um "das Enthalten eines Schlüssels" nicht mit "einen Wert" zu verwechseln. Zum Beispiel können HashMap s null enthalten. Dies bedeutet, dass das folgende Verhalten völlig normal ist:

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 
}

Formal gibt es keine Garantie, dass map.contains(key) <=> map.get(key)!=null

Karteneinträge effizient iterieren

Dieser Abschnitt enthält Code und Benchmarks für zehn eindeutige Beispielimplementierungen, die die Einträge einer Map<Integer, Integer> und die Summe der Integer Werte generieren. Alle Beispiele weisen eine algorithmische Komplexität von Θ(n) . Die Benchmarks sind jedoch immer noch nützlich, um Einblick zu gewinnen, welche Implementierungen in einer "realen" Umgebung effizienter sind.

1. Implementierung mit Iterator mit 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. Implementierung mit for mit Map.Entry

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

3. Implementierung mit Map.forEach (Java 8+)

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

4. Implementierung mit Map.keySet mit for

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

5. Implementierung mit Map.keySet mit Iterator

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

6. Implementierung mit for mit Iterator und 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. Implementierung mit Stream.forEach (Java 8+)

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

8. Implementierung mit Stream.forEach mit Stream.parallel (Java 8+)

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

9. Implementierung mit IterableMap aus Apache Collections

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

10. Implementierung mit MutableMap aus Eclipse Collections

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

Leistungstests ( Code auf Github verfügbar )
Testumgebung: Windows 8.1 64-Bit, Intel i7-4790 3,60 GHz, 16 GB

1. Durchschnittliche Leistung von 10 Versuchen (100 Elemente) 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. Durchschnittliche Leistung von 10 Versuchen (10000 Elemente) 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. Durchschnittliche Leistung von 10 Versuchen (100000 Elemente) 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. Ein Vergleich der Leistungsabweichungen in Bezug auf die Kartengröße

       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

Verwenden Sie ein benutzerdefiniertes Objekt als Schlüssel

Bevor Sie Ihr eigenes Objekt als Schlüssel verwenden, müssen Sie die Methode hashCode () und equals () Ihres Objekts überschreiben.

Im einfachen Fall hätten Sie so etwas wie:

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 entscheidet, zu welchem ​​Hash-Bucket der Schlüssel gehört, und equals entscheidet, welches Objekt in diesem Hash-Bucket liegt.

Ohne diese Methode wird die Referenz Ihres Objekts für den obigen Vergleich verwendet. Dies funktioniert nicht, wenn Sie nicht jedes Mal dieselbe Objektreferenz verwenden.

Verwendung von HashMap

HashMap ist eine Implementierung der Map-Schnittstelle, die eine Datenstruktur zum Speichern von Daten in Schlüssel-Wert-Paaren bereitstellt.

1. HashMap deklarieren

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

KeyType und ValueType müssen gültige Typen in Java sein, wie - String, Integer, Float oder eine benutzerdefinierte Klasse wie Employee, Student usw.

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

2. Werte in HashMap setzen.

Um einen Wert in die HashMap einzufügen, müssen Sie die put Methode für das HashMap-Objekt aufrufen put indem Sie die Parameter Key und Value als Parameter übergeben.

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

Wenn Sie die put-Methode mit dem bereits in der Map vorhandenen Key aufrufen, überschreibt die Methode ihren Wert und gibt den alten Wert zurück.

3. Werte von HashMap abrufen.

Um den Wert aus einer HashMap zu erhalten, müssen Sie die get Methode aufrufen, indem Sie den Key als Parameter übergeben.

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

Wenn Sie einen Schlüssel übergeben, der nicht in der HashMap vorhanden ist, gibt diese Methode null

4. Prüfen Sie, ob sich der Schlüssel in der Karte befindet oder nicht.

myMap.containsKey(varKey);

5. Prüfen Sie, ob sich der Wert in der Karte befindet oder nicht.

myMap.containsValue(varValue);

Die obigen Methoden geben einen boolean Wert true oder false zurück, wenn key, value in der Map vorhanden ist oder nicht.

Karten erstellen und initialisieren

Einführung

Maps speichert Schlüssel / Wert-Paare, wobei jedem Schlüssel ein Wert zugeordnet ist. Bei einem bestimmten Schlüssel kann die Karte den zugehörigen Wert sehr schnell nachschlagen.

Maps , auch assoziiertes Array genannt, ist ein Objekt, in dem die Daten in Form von Schlüsseln und Werten gespeichert werden. In Java werden Karten mit der Map-Schnittstelle dargestellt, die keine Erweiterung der Erfassungsschnittstelle ist.

• Weg 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);
  

• Weg 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);
  

• Weg 3: -

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

• Weg 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);
  

• Weg 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);
  

• Weg 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");
    }
  

• Möglichkeit 7: - Erstellen einer unveränderlichen Karte mit einem einzigen Schlüsselwert.

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

  Bitte beachten Sie, dass eine solche Karte nicht geändert werden kann .

  Jeder Versuch, die Karte zu ändern, löst die UnsupportedOperationException aus.

      //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