HashMap Java

Nouvelles fonctionnalités

Dans ce tutoriel, nous allons apprendre la classe HashMap de Java et ses méthodes à l'aide d'exemples.La classe HashMap de la bibliothèque de collections Java fournitInterface Map

d'une implémentation de table de hachage.

Créer une HashMap

//Pour créer une HashMap, nous devons d'abord importer le paquet java.util.HashMap. Après avoir importé le paquet, nous pouvons utiliser Java pour créer une table de hachage.8d'une capacité et 0.6HashMap de facteur de charge
HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);

Dans le code ci-dessus, nous avons créé une HashMap nommée numbers.

Ici,

• Key -Identifiant unique utilisé pour lier chaque élément (valeur) de la map

• Value -L'élément associé à la clé dans la 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);
　　　　}
}

Output result

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

HashMap的方法

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

将元素插入HashMap

• put() - 将指定的键/值映射插入到map中

• putAll() - 将指定map的所有条目插入此map

• putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中

Par exemple,

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

Output result

偶数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所有值的集合

Par exemple,

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

Output result

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() - 返回与指定键关联的值。如果找不到键，则返回指定的默认值。

Par exemple,

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

Output result

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

删除元素

• remove(key)　 - 返回并从映射中删除与指定键相关联的项

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

Par exemple,

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("条目"3A-t-il été supprimé ? ")　+　result);
　　　　　　　　System.out.println("HashMap mis à jour: ")　+　numbers);
　　　　}
}

Output result

HashMap: {One=1, Two=2, Three=3}
Suppression de la valeur:　2
Entrée3A-t-il été supprimé ? True
HashMap mis à jour: {One=1}

Remplacer l'élément

• replace(key, value) - Remplacer la valeur de la clé

• replace(key, old, new) - Seulement lorsque l'ancienne valeur old est déjà associée à la clé spécifiée key, remplacer l'ancienne valeur par la nouvelle valeur

• replaceAll(function) - Remplacer chaque valeur de la carte par le résultat de la fonction spécifiée

Par exemple,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　Cependant, si la clé spécifiée est déjà associée à une valeur, elle fusionnera la nouvelle valeur spécifiée avec la valeur ancienne existante. Par exemple　1);
　　　　　　　　numbers.put("First",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("HashMap original: ")　+　numbers);
　　　　　　　　//　Utilisation de replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("Utilisation de replace pour remplacer la valeur de HashMap: ")　+　numbers);
　　　　　　　　//　Utilisation de replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　-,　(oldValue,　newValue)　+　2);
　　　　　　　　System.out.println("Utilisation de replaceAll pour remplacer la valeur de HashMap: ")　+　numbers);
　　　　}
}

Output result

HashMap original: {Second=2, Third=3Nouveau HashMap :　{Second=1}
Utilisation de replace pour remplacer la valeur de HashMap: {Second=22, Third=33Nouveau HashMap :　{Second=1}
Utilisation de replaceAll pour remplacer la valeur de HashMap: {Second=24, Third=35Nouveau HashMap :　{Second=3}

Dans le programme ci-dessus, veuillez noter l'instruction

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

Dans ce cas, cette méthode accède à toutes les entrées de la map. Ensuite, elle remplace toutes les valeurs parIci, nous utilisonsLa nouvelle valeur fournie.

Recalculer la valeur

1.Utilisation de la méthode compute()

• compute() - Utilisation de la fonction spécifiée pour calculer une nouvelle valeur. Ensuite, cette valeur calculée sera associée à la clé spécifiée.

• computeIfAbsent() - Si la clé spécifiée n'est pas associée à aucune valeur, cette méthode utilisera la fonction spécifiée pour calculer une nouvelle valeur. Ensuite, cette nouvelle valeur sera associée à la clé.

• computeIfPresent() -Si la clé spécifiée est déjà associée à une valeur, cette méthode utilisera la fonction spécifiée pour calculer une nouvelle valeur. Ensuite, cette nouvelle valeur sera associée à la clé.

Par exemple,

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　Cependant, si la clé spécifiée est déjà associée à une valeur, elle fusionnera la nouvelle valeur spécifiée avec la valeur ancienne existante. Par exemple　1);
　　　　　　　　numbers.put("First",　2);
　　　　　　　　numbers.put("Second",　+　numbers);
　　　　　　　　//　Utilisation de compute()
　　　　　　　　numbers.compute("First", (key, oldValue)　-,　(oldValue,　newValue)　+　2);
　　　　　　　　numbers.compute("Second", (key, oldValue)　-,　(oldValue,　newValue)　+　1);
　　　　　　　　System.out.println("HashMap utilisation de compute(): ")　+　numbers);
　　　　　　　　//　使用　computeIfAbsent()
　　　　　　　　Utilisation de computeIfAbsent()　-numbers.computeIfAbsent("Three",　key　5);
　　　　　　　　>　+　numbers);
　　　　　　　　//　System.out.println("HashMap utilise computeIfAbsent():　"
　　　　　　　　Utilisation de computeIfPresent()　-,　(oldValue,　newValue)　*　2);
　　　　　　　　numbers.computeIfPresent("Second",　(key,　oldValue)　+　numbers);
　　　　}
}

Output result

System.out.println("Nouveau HashMap :　"2Nouveau HashMap :　{Second=1}
System.out.println("HashMap utilise computeIfPresent():　"3Nouveau HashMap :　{Second=3}
HashMap utilise compute():　{Second=3　HashMap utilise computeIfAbsent():　{Second=3, Three=5}
First=6Nouveau HashMap :　{Second=3HashMap utilise computeIfPresent():　{Second=5}

,　three=

Dans l'exemple ci-dessus, nous avons utilisé la méthode compute() pour recalculer la valeur de la carte.Ici, nous utilisonsexpression lambda

2comme paramètre de méthode pour recalculer la valeur.

.Utilisation de la méthode merge()

Si la clé spécifiée n'est pas encore associée, la méthode merge() associera la valeur spécifiée à la clé spécifiée.

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　Cependant, si la clé spécifiée est déjà associée à une valeur, elle fusionnera la nouvelle valeur spécifiée avec la valeur ancienne existante. Par exemple　1);
　　　　　　　　numbers.put("First",　2);
　　　　　　　　numbers.put("Second",　+　numbers);
　　　　　　　　//　System.out.println("HashMap original :　"
　　　　　　　　Utilisation de la méthode merge()　4numbers.merge("First",　-,　(oldValue,　newValue)　+　>　oldValue
　　　　　　　　newValue);　+　numbers);
　　　　}
}

Output result

System.out.println("Nouveau HashMap :　"2Nouveau HashMap :　{Second=1}
HashMap original :　{Second=2Nouveau HashMap :　{Second=5}

,　First=3Dans l'exemple ci-dessus, la méthode merge() utiliseun paramètre :key,newValue

Et une expression lambda (utilisée pour calculer la nouvelle valeur de fusion).

Parcourir HashMap

Dans HashMap, nous pouvons

• Parcourir clé

• Parcourir valeur

• Parcourir clé/valeur

1.Utilisation de la boucle foreach

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Accéder à la clé/valeur (clé/paire de valeurs
　　　　　　　　System.out.print("Élément: ");
　　　　　　　　for(Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//Accéder à la clé
　　　　　　　　System.out.print("\nAll keys: ");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//access value
　　　　　　　　System.out.print("\nAll values: ");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

HashMap: {One=1, Two=2, Three=3}
All entries: One=1, Two=2, Three=3
All keys: One, Two, Three,
All values:　1,　2, ,3,

Dans le programme ci-dessus, notez que nous avons importé le paquet java.util.Map.Entry. Ici, Map.Entry est une classe imbriquée de l'interface Map.

This nested class returns a view of the map (elements).

2.Utilisation de la méthode iterator()

Il est également possible d'utiliser la méthode iterator() pour itérer sur un HashMap. Pour utiliser cette méthode, nous devons importer le paquet java.util.Iterator.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Créer un objet Iterator
　　　　　　　　Iterator<Entry<String, Integer>> iterate1　= numbers.entrySet().iterator();
　　　　　　　　//　Accéder à la Clé/Paire de valeurs
　　　　　　　　System.out.print("Tous les éléments: ");
　　　　　　　　while(iterate1.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Accéder à la clé
　　　　　　　　Iterator<String> iterate2　= numbers.keySet().iterator();
　　　　　　　　System.out.print("\nAll keys: ");
　　　　　　　　while(iterate2.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　access value
　　　　　　　　Iterator<Integer> iterate3　= numbers.values().iterator();
　　　　　　　　　System.out.print("\nAll values: ");
　　　　　　　　while(iterate3.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

HashMap: {One=1, Two=2, Three=3}
All entries: One=1, Two=2, Three=3
All keys: One, Two, Three,
All values:　1,　2,　3,

In the above program, please note that we have imported the java.util.Map.Entry package. Here Map.Entry is a nested class of the Map interface.

This nested class returns a view of the map (elements).