Java Grund教程

Online-Tools

each-Schleife

Java Array

Java objektorientiert (I)

Java objektorientiert (II)

Java Ausnahmebehandlung

resources

Java 列表(List)

Java Queue(队列)

Java Map-Sammlung

Java Set-Sammlung/Java 输入输出(I

O Stream/Java Reader

Writer

Java Methodenüberschreibung Java Map Interface

Java HashMap

Neue Funktionen

In diesem Tutorial werden wir mit Beispielen die HashMap-Klasse und ihre Methoden des Java HashMap lernen.Die HashMap-Klasse der Java Collection Framework bietetMap-Schnittstelle

die Implementierung der Hash-Tabelle ist.

Eine HashMap erstellen

//Um eine HashMap zu erstellen, müssen wir zunächst das Paket java.util.HashMap importieren. Nach dem Import des Pakets können wir mit Java eine Hash-Tabelle erstellen.8eine Kapazität und 0.6Die HashMap für den Lastfaktor
HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);

Im obigen Code haben wir eine HashMap namens numbers erstellt.

Hier,

Key -Ein einzigartiger Identifikator zur Verknüpfung jedes Elements (Werts) im Map
Wert -Der mit dem Schlüssel verbundene Element im Map

请注意 new HashMap<>(8,0.6) 部分。这里，第一个参数是capacity，第二个参数是loadFactor。

capacity - HashMap的容量为8。意味着，它可以存储8个条目。
loadFactor -　 hashmap的负载因子为0.6。这意味着，每当哈希表被填满60%时，条目就会被移动到一个新哈希表，其大小是原始哈希表的两倍。

默认容量和负载因子

创建哈希表而不定义其容量和负载因子是允许的。例如，

//具有默认容量和负载因子的HashMap
HashMap<Key,　Value>　numbers1　=　new　HashMap<>();

默认，

HashMap的容量将为 16
负载因子将为 0.75

从其他map创建HashMap

这是我们如何创建包含其他map的所有元素的HashMap的方法。

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数的hashmap
　　　　　　　　HashMap<String,　Integer>　evenNumbers　=　new　HashMap<>();
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　System.out.println("HashMap1:　"　+　evenNumbers);
　　　　　　　　//从其他hashmap创建一个hashmap
　　　　　　　　HashMap<String,　Integer>　numbers　=　new　HashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap2:　"　+　numbers);
　　　　}
}

Ausgabefolge

HashMap1:　{Four=4, Two=2}
HashMap2:　{Two=2, Three=3, Four=4}

HashMap的方法

本HashMap类提供各种方法，使我们能够在map上进行各种操作。

将元素插入HashMap

put() - 将指定的键/值映射插入到map中
putAll() - 将指定map的所有条目插入此map
putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数HashMap
　　　　　　　　HashMap<String,　Integer>　evenNumbers　=　new　HashMap<>();
　　　　　　　　//　使用　put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　使用　putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("偶数HashMap:　"　+　evenNumbers);
　　　　　　　　//Creating　HashMap　of　numbers
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　使用　putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("numbers的HashMap: ")　+　numbers);
　　　　}
}

Ausgabefolge

偶数HashMap: {Six=6, Four=4, Two=2}
numbers的HashMap: {Six=6, One=1, Four=4, Two=2}

访问HashMap元素

1.使用entrySet()，keySet()和values()

entrySet() -返回一组所有键/值映射的map
keySet() -返回map所有键的集合
values() -返回map所有值的集合

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//　使用 entrySet()
　　　　　　　　System.out.println("Key/Value 映射:　+　numbers.entrySet());
　　　　　　　　//　使用 keySet()
　　　　　　　　System.out.println("Keys: "　+　numbers.keySet());
　　　　　　　　//　使用 values()
　　　　　　　　System.out.println("Values: "　+　numbers.values());
　　　　}
}

Ausgabefolge

HashMap: {One=1, Two=2, Three=3}
Key/Value 映射: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1,　2,　3]

2.使用get()和getOrDefault()

get() - 返回与指定键关联的值。如果找不到键，则返回null。
getOrDefault() - 返回与指定键关联的值。如果找不到键，则返回指定的默认值。

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//　使用 get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("返回数字: "　+　value1);
　　　　　　　　//　使用 getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("返回数字: "　+　value2);
　　　　}
}

Ausgabefolge

HashMap: {One=1, Two=2, Three=3}
返回数字:　3
返回数字:　5

删除元素

remove(key)　 - 返回并从映射中删除与指定键相关联的项
remove(key, value)　 - 仅当指定键映射到指定值并返回布尔值时，才从映射中删除该项

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//单个参数的删除方法
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("删除值: "　+　value);
　　　　　　　　//具有两个参数的删除方法
　　　　　　　　boolean result = numbers.remove("Three",)　3);
　　　　　　　　System.out.println("条目")3被删除了吗? "　+　result);
　　　　　　　　System.out.println("更新后的HashMap: ")　+　numbers);
　　　　}
}

Ausgabefolge

HashMap: {One=1, Two=2, Three=3}
删除值:　2
条目3被删除了吗? True
更新后的HashMap: {One=1}

替换元素

replace(key, value) - 将key的值替换为value
replace(key, old, new) - 仅当old值已与指定键key关联时，才用new值替换old值
replaceAll(function) - 用指定函数的结果替换映射的每个值

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("原始HashMap: ")　+　numbers);
　　　　　　　　//　使用 replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("使用replace替换HashMap的值: ")　+　numbers);
　　　　　　　　//　使用 replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　->　oldValue　+　2);
　　　　　　　　System.out.println("使用replaceAll替换HashMap的值: ")　+　numbers);
　　　　}
}

Ausgabefolge

原始HashMap: {Second=2, Third=3,　First=1}
使用replace替换HashMap的值: {Second=22, Third=33,　First=1}
使用replaceAll替换HashMap的值: {Second=24, Third=35,　First=3}

在上述程序中，注意语句

numbers.replaceAll((key, oldValue)　->　oldValue　+　2);

在此，该方法访问map的所有条目。然后，它将所有值替换为Lambda-Ausdruck提供的新值。

重新计算值

1.使用compute()方法

compute() - 使用指定的函数计算新值。然后将计算值与指定的键相关联。
computeIfAbsent() - 如果指定的键没有映射到任何值，该方法将使用指定的函数计算一个新值。然后将新值与键关联。
computeIfPresent() -如果指定的键已经映射到任何值，此方法将使用指定的函数计算一个新值。然后将新值与键关联。

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("Ursprüngliche HashMap：　"　+　numbers);
　　　　　　　　//　使用 compute()
　　　　　　　　numbers.compute("First", (key, oldValue)　->　oldValue　+　2);
　　　　　　　　numbers.compute("Second", (key, oldValue)　->　oldValue　+　1);
　　　　　　　　System.out.println("HashMap 使用 compute(): ")　+　numbers);
　　　　　　　　//　Verwenden Sie die　computeIfAbsent()
　　　　　　　　numbers.computeIfAbsent("Three",　key　->　5);
　　　　　　　　System.out.println("HashMap　verwendet　computeIfAbsent():　"　+　numbers);
　　　　　　　　//　Verwenden Sie die　computeIfPresent()
　　　　　　　　numbers.computeIfPresent("Second",　(key,　oldValue)　->　oldValue　*　2);
　　　　　　　　System.out.println("HashMap　verwendet　computeIfPresent():　"　+　numbers);
　　　　}
}

Ausgabefolge

Ursprüngliche HashMap：　{Second=2,　First=1}
HashMap　verwendet　compute():　{Second=3,　First=3}
HashMap　verwendet　computeIfAbsent():　{Second=3　First=3, Three=5}
HashMap　verwendet　computeIfPresent():　{Second=6,　First=3,　three=5}

Im obigen Beispiel hat die compute()-Methode den Wert der Abbildung neu berechnet.

Hier verwenden wirLambda-Ausdruckals Methodenparameter, um den Wert neu zu berechnen.

2.Verwenden Sie die merge()-Methode

Wenn der angegebene Schlüssel noch nicht verknüpft ist, verknüpft die merge()-Methode den angegebenen Wert mit dem angegebenen Schlüssel.

Wenn der angegebene Schlüssel bereits mit einem Wert verknüpft ist, wird er den neuen angegebenen Wert mit dem bestehenden alten Wert zusammenlegen. Zum Beispiel

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("Ursprüngliche HashMap：　"　+　numbers);
　　　　　　　　//　Verwenden Sie die　merge()　Methode
　　　　　　　　numbers.merge("First",　4,　(oldValue,　newValue)　->　oldValue　+　newValue);
　　　　　　　　System.out.println("Neue HashMap：　"　+　numbers);
　　　　}
}

Ausgabefolge

Ursprüngliche HashMap：　{Second=2,　First=1}
Neue HashMap：　{Second=2,　First=5}

Im obigen Beispiel verwendet der merge()-Methoden3Parameter:key,newValueund einem Lambda-Ausdruck (zur Berechnung des neuen Zusammenlegungswerts).

Andere Methoden von HashMap

Methode	Beschreibung
clear()	Entfernen Sie alle Einträge aus der Abbildung
containsKey()	Überprüfen Sie, ob der Abbildung der angegebene Schlüssel enthalten ist und geben Sie den Boolean-Wert zurück
containsValue()	Überprüfen Sie, ob der Abbildung der angegebene Wert enthalten ist und geben Sie den Boolean-Wert zurück
size()	Geben Sie die Größe der Map zurück
isEmpty()	Überprüfen Sie, ob das Map-Objekt leer ist und geben Sie den Boolean-Wert zurück

durchsuchen HashMap

In der HashMap können wir

durchsuchen Schlüssel
durchsuchen Werte
durchsuchen Schlüssel/Werte

1.Verwenden Sie die forEach-Schleife

Beispiel

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie eine HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Zugriff auf den Schlüssel/Wert (key/Wertpaar
　　　　　　　　System.out.print("Projekt: ");
　　　　　　　　for(Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//Zugriff auf key
　　　　　　　　System.out.print("
Alle Schlüssel: ");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//Zugriff auf value
　　　　　　　　System.out.print("
Alle Werte: ");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgabefolge

HashMap: {One=1, Two=2, Three=3}
Alle Einträge: One=1, Two=2, Three=3
Alle Schlüssel: One, Two, Three,
Alle Werte:　1,　2, ,3,

Beachten Sie im obigen Programm, dass wir das Paket java.util.Map.Entry importiert haben. Hierbei ist Map.Entry eine eingebettete Klasse des Map-Interfaces.

Diese geschachtelte Klasse gibt die Ansicht des Maps (Elemente) zurück.

2.Verwenden Sie die iterator()-Methode

Man kann auch die iterator()-Methode zum Iterieren über eine HashMap verwenden. Um diese Methode zu verwenden, müssen wir das Paket java.util.Iterator importieren.

Beispiel

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie eine HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Erstellen Sie ein Iterator-Objekt
　　　　　　　　Iterator<Entry<String, Integer>> iterate1　= numbers.entrySet().iterator();
　　　　　　　　//　Zugriff auf Key/Wertpaar
　　　　　　　　System.out.print("alle Einträge: ");
　　　　　　　　while(iterate1.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Zugriff auf key
　　　　　　　　Iterator<String> iterate2　= numbers.keySet().iterator();
　　　　　　　　System.out.print("
Alle Schlüssel: ");
　　　　　　　　while(iterate2.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Zugriff auf value
　　　　　　　　Iterator<Integer> iterate3　= numbers.values().iterator();
　　　　　　　　　System.out.print("
Alle Werte: ");
　　　　　　　　while(iterate3.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgabefolge

HashMap: {One=1, Two=2, Three=3}
Alle Einträge: One=1, Two=2, Three=3
Alle Schlüssel: One, Two, Three,
Alle Werte:　1,　2,　3,

Im obigen Programm beachten Sie, dass wir das Paket java.util.Map.Entry importiert haben. Hier ist Map.Entry eine geschachtelte Klasse des Map-Interfaces.

Diese geschachtelte Klasse gibt die Ansicht des Maps (Elemente) zurück.

Java Methodenüberschreibung Java Map Interface