Java HashMap ist eine der beliebtesten Sammlungsklassen in Java. Java HashMap ist eine Implementierung basierend auf Hash-Tabellen. HashMap in Java erweitert die AbstractMap-Klasse, die das Map-Interface implementiert.
Java HashMap
Einige wichtige Punkte zu HashMap in Java sind;
- Java HashMap erlaubt null als Schlüssel und null als Werte.
- HashMap ist keine geordnete Sammlung. Sie können über die Einträge der HashMap über den Schlüsselsatz iterieren, aber es wird nicht garantiert, dass sie in der Reihenfolge ihrer Hinzufügung zur HashMap sind.
- HashMap ist fast identisch mit Hashtable, außer dass es nicht synchronisiert ist und null als Schlüssel und Werte zulässt.
- HashMap verwendet seine innere Klasse Node<K,V> zur Speicherung von Einträgen in der Map.
- HashMap speichert Einträge in mehreren einfach verketteten Listen, sogenannten Buckets oder Bins. Die Standardanzahl der Bins beträgt 16 und es ist immer eine Potenz von 2.
- HashMap verwendet die Methoden hashCode() und equals() auf Schlüsseln für get- und put-Operationen. Der Schlüsselobjekt der HashMap sollte also eine gute Implementierung dieser Methoden bereitstellen. Das ist der Grund, warum unveränderliche Klassen besser geeignet sind, zum Beispiel String und Integer.
- Java HashMap ist nicht threadsicher. Für eine Mehrfadenumgebung sollten Sie die ConcurrentHashMap-Klasse verwenden oder eine synchronisierte Map mit der Methode
Collections.synchronizedMap()erhalten.
Java HashMap Constructors
Java HashMap bietet vier Konstruktoren.
- public HashMap(): Dieser Konstruktor wird am häufigsten verwendet und erstellt eine leere HashMap mit der Standard-Anfangskapazität von 16 und einer Auslastungsfaktor von 0.75.
- public HashMap(int initialCapacity): Dieser Konstruktor ermöglicht die Angabe der Anfangskapazität und eines Auslastungsfaktors von 0.75. Dies ist nützlich, um eine Neuberechnung zu vermeiden, wenn Sie die Anzahl der Mappings in der HashMap kennen.
- public HashMap(int initialCapacity, float loadFactor): Dieser Konstruktor erstellt eine leere HashMap mit der angegebenen Anfangskapazität und dem Auslastungsfaktor. Sie können dies verwenden, wenn Sie die maximale Anzahl der zu speichernden Mappings kennen. In üblichen Szenarien sollten Sie dies vermeiden, da der Auslastungsfaktor 0.75 einen guten Kompromiss zwischen Speicher- und Zeitkosten bietet.
- public HashMap(Map<? extends K, ? extends V> m): Erstellt eine Map mit denselben Zuordnungen wie die angegebene Map und einem Auslastungsfaktor von 0.75
Java HashMap Konstruktoren Beispiel
Der folgende Code-Schnipsel zeigt ein Beispiel für die Verwendung aller oben genannten Konstruktoren.
Map<String, String> map1 = new HashMap<>();
Map<String, String> map2 = new HashMap<>(2^5);
Map<String, String> map3 = new HashMap<>(32,0.80f);
Map<String,String> map4 = new HashMap<>(map1);
Java HashMap Methoden
Werfen wir einen Blick auf die wichtigen Methoden von HashMap in Java.
- public void clear(): Diese HashMap-Methode entfernt alle Zuordnungen, und die HashMap wird leer.
- public boolean containsKey(Object key): Diese Methode gibt ‚true‘ zurück, wenn der Schlüssel existiert, andernfalls wird ‚false‘ zurückgegeben.
- public boolean containsValue(Object value): Diese HashMap-Methode gibt ‚true‘ zurück, wenn der Wert existiert, andernfalls ‚false‘.
- public Set<Map.Entry<K,V>> entrySet(): Diese Methode gibt eine Set-Ansicht der HashMap-Zuordnungen zurück. Dieses Set wird von der Map unterstützt, sodass Änderungen an der Map im Set und umgekehrt reflektiert werden.
- public V get(Object key): Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist, oder null, wenn keine Zuordnung für den Schlüssel vorhanden ist.
- public boolean isEmpty(): Eine Hilfsmethode, die ‚true‘ zurückgibt, wenn keine Schlüssel-Wert-Zuordnungen vorhanden sind.
- public Set<K> keySet(): Gibt eine Set-Ansicht der Schlüssel in dieser Map zurück. Das Set wird von der Map unterstützt, sodass Änderungen an der Map im Set und umgekehrt reflektiert werden.
- public V put(K key, V value): Ordnet den angegebenen Wert dem angegebenen Schlüssel in dieser Map zu. Wenn die Map zuvor eine Zuordnung für den Schlüssel enthielt, wird der alte Wert ersetzt.
- public void putAll(Map<? extends K, ? extends V> m): Kopiert alle Zuordnungen aus der angegebenen Map in diese Map. Diese Zuordnungen ersetzen alle Zuordnungen, die diese Map für eines der Schlüssel hat, die sich derzeit in der angegebenen Map befinden.
- public V remove(Object key): Entfernt die Zuordnung für den angegebenen Schlüssel aus dieser Map, falls vorhanden.
- public int size(): Gibt die Anzahl der Schlüssel-Wert-Zuordnungen in dieser Map zurück.
- public Collection<V> values(): Gibt eine Collection-Ansicht der Werte zurück, die in dieser Map enthalten sind. Die Sammlung wird von der Map unterstützt, sodass Änderungen an der Map in der Sammlung reflektiert werden und umgekehrt.
Es gibt viele neue Methoden in HashMap, die in Java 8 eingeführt wurden.
- public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction): Wenn der angegebene Schlüssel noch nicht mit einem Wert verknüpft ist (oder auf null abgebildet ist), versucht diese Methode, seinen Wert mithilfe der angegebenen Abbildungsfunktion zu berechnen und ihn in die HashMap einzutragen, es sei denn, er ist null.
- public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction): Wenn der Wert für den angegebenen Schlüssel vorhanden und nicht null ist, versucht, eine neue Zuordnung unter Verwendung des Schlüssels und seines aktuellen zugeordneten Werts zu berechnen.
- public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction): Diese HashMap-Methode versucht, eine Zuordnung für den angegebenen Schlüssel und seinen aktuellen zugeordneten Wert zu berechnen.
- public void forEach(BiConsumer action): Diese Methode führt die angegebene Aktion für jeden Eintrag in dieser Map aus.
- public V getOrDefault(Object key, V defaultValue): Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist, oder defaultValue, wenn kein Mapping für den angegebenen Schlüssel gefunden wurde.
- public V merge(K key, V value, BiFunction remappingFunction): Wenn der angegebene Schlüssel noch nicht mit einem Wert verknüpft ist oder mit null verknüpft ist, wird er mit dem angegebenen nicht-null Wert verknüpft. Andernfalls wird der zugehörige Wert durch das Ergebnis der angegebenen Umwandlungsfunktion ersetzt oder entfernt, wenn das Ergebnis null ist.
- public V putIfAbsent(K key, V value): Wenn der angegebene Schlüssel noch nicht mit einem Wert verknüpft ist (oder auf null abgebildet wird), wird er mit dem angegebenen Wert verknüpft und null zurückgegeben. Andernfalls wird der aktuelle Wert zurückgegeben.
- public boolean remove(Object key, Object value): Entfernt den Eintrag für den angegebenen Schlüssel nur, wenn er derzeit auf den angegebenen Wert abgebildet wird.
- public boolean replace(K key, V oldValue, V newValue): Ersetzt den Eintrag für den angegebenen Schlüssel nur, wenn er derzeit auf den angegebenen Wert abgebildet wird.
- public V replace(K key, V value): Ersetzt den Eintrag für den angegebenen Schlüssel nur, wenn er derzeit auf einen Wert abgebildet wird.
- public void replaceAll(BiFunction function): Ersetzt den Wert jedes Eintrags durch das Ergebnis des Aufrufs der angegebenen Funktion für diesen Eintrag.
Java HashMap Beispiel
Hier ist ein einfaches Java-Programm für die üblicherweise verwendeten Methoden von HashMap.
package com.journaldev.examples;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1"); // put example
map.put("2", "2");
map.put("3", "3");
map.put("4", null); // null value
map.put(null, "100"); // null key
String value = map.get("3"); // get example
System.out.println("Key = 3, Value = " + value);
value = map.getOrDefault("5", "Default Value");
System.out.println("Key = 5, Value=" + value);
boolean keyExists = map.containsKey(null);
boolean valueExists = map.containsValue("100");
System.out.println("keyExists=" + keyExists + ", valueExists=" + valueExists);
Set<Entry<String, String>> entrySet = map.entrySet();
System.out.println(entrySet);
System.out.println("map size=" + map.size());
Map<String, String> map1 = new HashMap<>();
map1.putAll(map);
System.out.println("map1 mappings= " + map1);
String nullKeyValue = map1.remove(null);
System.out.println("map1 null key value = " + nullKeyValue);
System.out.println("map1 after removing null key = " + map1);
Set<String> keySet = map.keySet();
System.out.println("map keys = " + keySet);
Collection<String> values = map.values();
System.out.println("map values = " + values);
map.clear();
System.out.println("map is empty=" + map.isEmpty());
}
}
Unten finden Sie die Ausgabe des oben genannten Java-HashMap-Beispielprogramms.
Key = 3, Value = 3
Key = 5, Value=Default Value
keyExists=true, valueExists=true
[null=100, 1=1, 2=2, 3=3, 4=null]
map size=5
map1 mappings= {null=100, 1=1, 2=2, 3=3, 4=null}
map1 null key value = 100
map1 after removing null key = {1=1, 2=2, 3=3, 4=null}
map keys = [null, 1, 2, 3, 4]
map values = [100, 1, 2, 3, null]
map is empty=true
Wie funktioniert HashMap in Java?
HashMap in Java verwendet seine innere Klasse Node<K,V> zur Speicherung von Zuordnungen. HashMap arbeitet mit einem Hashing-Algorithmus und verwendet die hashCode() und equals() Methode des Schlüssels für get- und put-Operationen. HashMap verwendet eine einfach verkettete Liste zur Speicherung von Elementen, die als Bins oder Buckets bezeichnet werden. Wenn wir die put-Methode aufrufen, wird der hashCode des Schlüssels verwendet, um den Bucket zu bestimmen, der zur Speicherung der Zuordnung verwendet wird. Sobald der Bucket identifiziert ist, wird der hashCode verwendet, um zu überprüfen, ob bereits ein Schlüssel mit demselben hashCode vorhanden ist oder nicht. Wenn es einen vorhandenen Schlüssel mit demselben hashCode gibt, wird die equals() Methode auf den Schlüssel angewendet. Wenn equals true zurückgibt, wird der Wert überschrieben, ansonsten wird eine neue Zuordnung zu diesem einfach verketteten Listen-Bucket gemacht. Wenn es keinen Schlüssel mit demselben hashCode gibt, wird die Zuordnung in den Bucket eingefügt. Für die HashMap get-Operation wird wiederum der Schlüssel hashCode verwendet, um den Bucket zu bestimmen, in dem nach dem Wert gesucht wird. Nachdem der Bucket identifiziert wurde, werden die Einträge durchlaufen, um den Eintrag mithilfe von hashCode und equals-Methode zu finden. Wenn ein Treffer gefunden wird, wird der Wert zurückgegeben, sonst null. Es gibt noch viele weitere Dinge wie den Hashing-Algorithmus, um den Bucket für den Schlüssel zu erhalten, das Rehashing von Zuordnungen usw. Aber für unsere Arbeit sollten wir uns einfach daran erinnern, dass HashMap-Operationen auf dem Schlüssel arbeiten und eine gute Implementierung der hashCode- und equals-Methode erforderlich ist, um unerwünschtes Verhalten zu vermeiden. Das folgende Bild zeigt die Erläuterung der get- und put-Operationen. 
Empfohlene Lektüre: Wichtigkeit der hashCode- und equals-Methode in Java
Java HashMap Load Factor
Die Lastfaktor wird verwendet, um herauszufinden, wann die HashMap neu gehasht wird und die Eimergröße erhöht wird. Der Standardwert für Eimer oder Kapazität beträgt 16 und der Lastfaktor beträgt 0,75. Die Schwelle für das Neu-Hashing wird berechnet, indem die Kapazität und der Lastfaktor multipliziert werden. Der Standard-Schwellenwert beträgt daher 12. Wenn die HashMap mehr als 12 Zuordnungen hat, wird sie neu gehasht und die Anzahl der Behälter auf die nächste Potenz von 2 erhöht, d. h. 32. Beachten Sie, dass die Kapazität der HashMap immer eine Potenz von 2 ist. Der Standard-Lastfaktor von 0,75 bietet einen guten Kompromiss zwischen Speicherplatz und Zeitkomplexität. Sie können ihn jedoch je nach Bedarf auf verschiedene Werte setzen. Wenn Sie Speicherplatz sparen möchten, können Sie seinen Wert auf 0,80 oder 0,90 erhöhen, aber dann dauern die Get/Put-Operationen länger.
Java HashMap keySet
Die Java HashMap keySet-Methode gibt die Set-Ansicht der Schlüssel in der HashMap zurück. Diese Set-Ansicht wird von der HashMap unterstützt und alle Änderungen in der HashMap werden im Set und umgekehrt reflektiert. Unten finden Sie ein einfaches Programm, das Beispiele für HashMap keySet zeigt und was zu tun ist, wenn Sie ein keySet möchten, das nicht von der Map unterstützt wird.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class HashMapKeySetExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
Set<String> keySet = map.keySet();
System.out.println(keySet);
map.put("4", "4");
System.out.println(keySet); // keySet is backed by Map
keySet.remove("1");
System.out.println(map); // map is also modified
keySet = new HashSet<>(map.keySet()); // copies the key to new Set
map.put("5", "5");
System.out.println(keySet); // keySet is not modified
}
}
Die Ausgabe des obigen Programms wird deutlich machen, dass keySet von der Map unterstützt wird.
[1, 2, 3]
[1, 2, 3, 4]
{2=2, 3=3, 4=4}
[2, 3, 4]
Java HashMap Werte
Die Java HashMap-Methode `values` gibt eine Sammlungsansicht der Werte in der Map zurück. Diese Sammlung wird von der HashMap unterstützt, sodass Änderungen an der HashMap sich in der Wertsammlung widerspiegeln und umgekehrt. Ein einfaches Beispiel unten bestätigt dieses Verhalten der HashMap-Wertsammlung.
package com.journaldev.examples;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class HashMapValuesExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", null);
map.put("4", null);
map.put(null, "100");
Collection<String> values = map.values();
System.out.println("map values = " + values);
map.remove(null);
System.out.println("map values after removing null key = " + values);
map.put("5", "5");
System.out.println("map values after put = " + values);
System.out.println(map);
values.remove("1"); // changing values collection
System.out.println(map); // updates in map too
}
}
Die Ausgabe des obigen Programms ist unten dargestellt.
map values = [100, 1, 2, null, null]
map values after removing null key = [1, 2, null, null]
map values after put = [1, 2, null, null, 5]
{1=1, 2=2, 3=null, 4=null, 5=5}
{2=2, 3=null, 4=null, 5=5}
Java HashMap entrySet
Die Java HashMap-Methode `entrySet` gibt die Set-Ansicht der Zuordnungen zurück. Dieses `entrySet` wird von der HashMap unterstützt, sodass Änderungen in der Map sich im Eintragsset widerspiegeln und umgekehrt. Werfen Sie einen Blick auf das folgende Beispielprogramm für ein HashMap-`entrySet`-Beispiel.
package com.journaldev.examples;
import java.util.AbstractMap;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapEntrySetExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", null);
map.put(null, "100");
Set<Entry<String,String>> entrySet = map.entrySet();
Iterator<Entry<String, String>> iterator = entrySet.iterator();
Entry<String, String> next = null;
System.out.println("map before processing = "+map);
System.out.println("entrySet before processing = "+entrySet);
while(iterator.hasNext()){
next = iterator.next();
System.out.println("Processing on: "+next.getValue());
if(next.getKey() == null) iterator.remove();
}
System.out.println("map after processing = "+map);
System.out.println("entrySet after processing = "+entrySet);
Entry<String, String> simpleEntry = new AbstractMap.SimpleEntry<String, String>("1","1");
entrySet.remove(simpleEntry);
System.out.println("map after removing Entry = "+map);
System.out.println("entrySet after removing Entry = "+entrySet);
}
}
Unten ist die Ausgabe des obigen Programms dargestellt.
map before processing = {null=100, 1=1, 2=null}
entrySet before processing = [null=100, 1=1, 2=null]
Processing on: 100
Processing on: 1
Processing on: null
map after processing = {1=1, 2=null}
entrySet after processing = [1=1, 2=null]
map after removing Entry = {2=null}
entrySet after removing Entry = [2=null]
Java HashMap putIfAbsent
A simple example for HashMap putIfAbsent method introduced in Java 8.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
public class HashMapPutIfAbsentExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", null);
map.put(null, "100");
System.out.println("map before putIfAbsent = "+map);
String value = map.putIfAbsent("1", "4");
System.out.println("map after putIfAbsent = "+map);
System.out.println("putIfAbsent returns: "+value);
System.out.println("map before putIfAbsent = "+map);
value = map.putIfAbsent("3", "3");
System.out.println("map after putIfAbsent = "+map);
System.out.println("putIfAbsent returns: "+value);
}
}
Die Ausgabe des obigen Programms ist unten aufgeführt;
map before putIfAbsent = {null=100, 1=1, 2=null}
map after putIfAbsent = {null=100, 1=1, 2=null}
putIfAbsent returns: 1
map before putIfAbsent = {null=100, 1=1, 2=null}
map after putIfAbsent = {null=100, 1=1, 2=null, 3=3}
putIfAbsent returns: null
Java HashMap forEach
Die HashMap forEach-Methode wurde in Java 8 eingeführt. Es ist eine sehr nützliche Methode, um die angegebene Aktion für jeden Eintrag in der Map auszuführen, bis alle Einträge verarbeitet wurden oder die Aktion eine Ausnahme wirft.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class HashMapForEachExample {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("1", "1");
map.put("2", null);
map.put(null, "100");
BiConsumer action = new MyBiConsumer();
map.forEach(action);
//Beispiel für Lambda-Ausdruck
System.out.println("\nHashMap forEach lambda example\n");
map.forEach((k,v) -> {System.out.println("Key = "+k+", Value = "+v);});
}
}
class MyBiConsumer implements BiConsumer {
@Override
public void accept(String t, String u) {
System.out.println("Key = " + t);
System.out.println("Processing on value = " + u);
}
}
Die Ausgabe des obigen HashMap forEach-Beispielprogramms ist:
Key = null
Processing on value = 100
Key = 1
Processing on value = 1
Key = 2
Processing on value = null
HashMap forEach lambda example
Key = null, Value = 100
Key = 1, Value = 1
Key = 2, Value = null
Java HashMap replaceAll
Die HashMap replaceAll-Methode kann verwendet werden, um den Wert jedes Eintrags durch das Ergebnis des Aufrufs der angegebenen Funktion für diesen Eintrag zu ersetzen. Diese Methode wurde in Java 8 hinzugefügt und wir können Lambda-Ausdrücke für dieses Methodenargument verwenden.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
public class HashMapReplaceAllExample {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put(null, "100");
System.out.println("map before replaceAll = " + map);
BiFunction function = new MyBiFunction();
map.replaceAll(function);
System.out.println("map after replaceAll = " + map);
//Ersetzen mit Lambda-Ausdrücken
map.replaceAll((k, v) -> {
if (k != null) return k + v;
else return v;});
System.out.println("map after replaceAll lambda expression = " + map);
}
}
class MyBiFunction implements BiFunction {
@Override
public String apply(String t, String u) {
if (t != null)
return t + u;
else
return u;
}
}
Die Ausgabe des obigen HashMap replaceAll-Programms ist:
map before replaceAll = {null=100, 1=1, 2=2}
map after replaceAll = {null=100, 1=11, 2=22}
map after replaceAll lambda example = {null=100, 1=111, 2=222}
Java HashMap computeIfAbsent
Die HashMap computeIfAbsent-Methode berechnet den Wert nur, wenn der Schlüssel nicht in der Map vorhanden ist. Nachdem der Wert berechnet wurde, wird er in die Map eingefügt, wenn er nicht null ist.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
public class HashMapComputeIfAbsent {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("1", "10");
map.put("2", "20");
map.put(null, "100");
Function function = new MyFunction();
map.computeIfAbsent("3", function); //key not present
map.computeIfAbsent("2", function); //key already present
//Lambda-Version
map.computeIfAbsent("4", v -> {return v;});
map.computeIfAbsent("5", v -> {return null;}); //null value won't get inserted
System.out.println(map);
}
}
class MyFunction implements Function {
@Override
public String apply(String t) {
return t;
}
}
Die Ausgabe des obigen Programms ist:
{null=100, 1=10, 2=20, 3=3, 4=4}
Java HashMap computeIfPresent
Java HashMap computeIfPresent Methode berechnet den Wert neu, wenn der angegebene Schlüssel vorhanden ist und der Wert nicht null ist. Wenn die Funktion null zurückgibt, wird die Zuordnung entfernt.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
public class HashMapComputeIfPresentExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "10");
map.put("2", "20");
map.put(null, "100");
map.put("10", null);
System.out.println("map before computeIfPresent = " + map);
BiFunction<String, String, String> function = new MyBiFunction1();
for (String key : map.keySet()) {
map.computeIfPresent(key, function);
}
System.out.println("map after computeIfPresent = " + map);
map.computeIfPresent("1", (k,v) -> {return null;}); // mapping will be removed
System.out.println("map after computeIfPresent = " + map);
}
}
class MyBiFunction1 implements BiFunction<String, String, String> {
@Override
public String apply(String t, String u) {
return t + u;
}
}
Die Ausgabe des HashMap computeIfPresent Beispiels ist;
map before computeIfPresent = {null=100, 1=10, 2=20, 10=null}
map after computeIfPresent = {null=null100, 1=110, 2=220, 10=null}
map after computeIfPresent = {null=null100, 2=220, 10=null}
Java HashMap berechnen
Wenn Sie eine Funktion auf alle Zuordnungen basierend auf ihrem Schlüssel und Wert anwenden möchten, sollte die compute Methode verwendet werden. Wenn keine Zuordnung vorhanden ist und diese Methode verwendet wird, ist der Wert für die compute Funktion null.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
public class HashMapComputeExample {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put(null, "10");
map.put("10", null);
System.out.println("map before compute = "+map);
for (String key : map.keySet()) {
map.compute(key, (k,v) -> {return k+v;});
}
map.compute("5", (k,v) -> {return k+v;}); //key not present, v = null
System.out.println("map after compute = "+map);
}
}
Die Ausgabe des HashMap-Berechnungsbeispiels ist;
map before compute = {null=10, 1=1, 2=2, 10=null}
map after compute = {null=null10, 1=11, 2=22, 5=5null, 10=10null}
Java HashMap zusammenführen
Wenn der angegebene Schlüssel nicht vorhanden ist oder mit null verbunden ist, wird er mit dem angegebenen nicht null-Wert verbunden. Andernfalls ersetzt den zugeordneten Wert durch die Ergebnisse der angegebenen Remapping-Funktion oder entfernt sie, wenn das Ergebnis null ist.
package com.journaldev.examples;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class HashMapMergeExample {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put(null, "10");
map.put("10", null);
for (Entry entry : map.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
//merge wirft NullPointerException, wenn Schlüssel oder Wert null sind
if(key != null && value != null)
map.merge(entry.getKey(), entry.getValue(),
(k, v) -> {return k + v;});
}
System.out.println(map);
map.merge("5", "5", (k, v) -> {return k + v;}); // key not present
System.out.println(map);
map.merge("1", "1", (k, v) -> {return null;}); // method return null, so remove
System.out.println(map);
}
}
Die Ausgabe des obigen Programms ist;
{null=10, 1=11, 2=22, 10=null}
{null=10, 1=11, 2=22, 5=5, 10=null}
{null=10, 2=22, 5=5, 10=null}
Das ist alles für HashMap in Java, ich hoffe, dass nichts Wichtiges übersehen wurde. Teile es auch mit anderen, wenn es dir gefallen hat. Referenz: API-Dokumentation
Source:
https://www.digitalocean.com/community/tutorials/java-hashmap