Java HashMap

Carte de hachage Java

Dans ce tutoriel, nous allons découvrir la classe Java HashMap et ses différentes opérations à l'aide d'exemples.

Le HashMap La classe du framework de collections Java fournit la fonctionnalité de la structure de données de la table de hachage.

Il stocke les éléments dans clé/valeur paires. Ici, les clés sont des identifiants uniques utilisés pour associer chaque valeur sur une carte.

Le HashMap classe implémente l'interface Map.

Créer une carte de hachage

Afin de créer une carte de hachage, nous devons importer le java.util.HashMap paquet d'abord. Une fois le package importé, voici comment créer des hashmaps en Java.

// hashMap creation with 8 capacity and 0.6 load factor
HashMap<K, V> numbers = new HashMap<>();

Dans le code ci-dessus, nous avons créé un hashmap nommé numbers . Ici, K représente le type de clé et V représente le type de valeurs. Par exemple,

HashMap<String, Integer> numbers = new HashMap<>();

Ici, le type de clés est String et le type de valeurs est Integer .

Exemple 1 :Créer un HashMap en Java

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> languages = new HashMap<>();

    // add elements to hashmap
    languages.put("Java", 8);
    languages.put("JavaScript", 1);
    languages.put("Python", 3);
    System.out.println("HashMap: " + languages);
  }
}

Sortie

HashMap: {Java=8, JavaScript=1, Python=3}

Dans l'exemple ci-dessus, nous avons créé un HashMap langues nommées .

Ici, nous avons utilisé le put() méthode pour ajouter des éléments au hashmap. Nous en apprendrons plus sur le put() méthode plus loin dans ce didacticiel.

Opérations de base sur Java HashMap

Le HashMap La classe fournit diverses méthodes pour effectuer différentes opérations sur les hashmaps. Nous examinerons certaines opérations d'arraylist couramment utilisées dans ce didacticiel :

Ajouter des éléments
Éléments d'accès
Modifier des éléments
Supprimer des éléments

1. Ajouter des éléments à un HashMap

Pour ajouter un seul élément au hashmap, nous utilisons le put() méthode du HashMap classer. Par exemple,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> numbers = new HashMap<>();

    System.out.println("Initial HashMap: " + numbers);
    // put() method to add elements
    numbers.put("One", 1);
    numbers.put("Two", 2);
    numbers.put("Three", 3);
    System.out.println("HashMap after put(): " + numbers);
  }
}

Sortie

Initial HashMap: {}
HashMap after put(): {One=1, Two=2, Three=3}

Dans l'exemple ci-dessus, nous avons créé un HashMap numéros nommés . Ici, nous avons utilisé le put() méthode pour ajouter des éléments aux nombres.

Remarquez la déclaration,

numbers.put("One", 1);

Ici, on passe le String valeur Un comme clé et Integer valeur 1 comme valeur du put() méthode.

Lectures recommandées

Java HashMap put()
Java HashMap putAll()
Java HashMap putIfAbsent()

2. Accéder aux éléments HashMap

Nous pouvons utiliser le get() méthode pour accéder à la valeur du hashmap. Par exemple,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // get() method to get value
    String value = languages.get(1);
    System.out.println("Value at index 1: " + value);
  }
}

Sortie

HashMap: {1=Java, 2=Python, 3=JavaScript}
Value at index 1: Java

Dans l'exemple ci-dessus, notez l'expression,

languages.get(1);

Ici, le get() la méthode prend la clé comme argument et renvoie la valeur correspondante associé à la clé.

Nous pouvons également accéder aux clés , valeurs , et clé/valeur paires de hashmap en tant que vues définies à l'aide de keySet() , values() , et entrySet() méthodes respectivement. Par exemple,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    HashMap<Integer, String> languages = new HashMap<>();

    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // return set view of keys
    // using keySet()
    System.out.println("Keys: " + languages.keySet());

    // return set view of values
    // using values()
    System.out.println("Values: " + languages.values());

    // return set view of key/value pairs
    // using entrySet()
    System.out.println("Key/Value mappings: " + languages.entrySet());
  }
}

Sortie

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: [1, 2, 3]
Values: [Java, Python, JavaScript]
Key/Value mappings: [1=Java, 2=Python, 3=JavaScript]

Dans l'exemple ci-dessus, nous avons créé un hashmap nommé langues . Ici, nous accédons aux clés , valeurs , et clé/valeur mappages à partir du hashmap.

Lectures recommandées

HashMap Java get()
Hashmap Java getOrDefault()
Ensemble de clés Java HashMap()
Valeurs Java HashMap()
Java HashMap entrySet()

3. Modifier la valeur de la carte de hachage

Nous pouvons utiliser le replace() méthode pour changer la valeur associée à une clé dans un hashmap. Par exemple,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("Original HashMap: " + languages);

    // change element with key 2
    languages.replace(2, "C++");
    System.out.println("HashMap using replace(): " + languages);
  }
}

Sortie

Original HashMap: {1=Java, 2=Python, 3=JavaScript}
HashMap using replace(): {1=Java, 2=C++, 3=JavaScript}

Dans l'exemple ci-dessus, nous avons créé un hashmap nommé langues . Remarquez l'expression,

languages.replace(2, "C++");

Ici, nous modifions la valeur référencée par la clé 2 avec la nouvelle valeur C++ .

Le HashMap la classe fournit également quelques variantes du replace() méthode. Pour en savoir plus, visitez

Java HashMap remplace()
Java HashMap replaceAll()

4. Supprimer les éléments HashMap

Pour supprimer des éléments d'un hashmap, nous pouvons utiliser la méthode remove(). Par exemple,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // remove element associated with key 2
    String value = languages.remove(2);
    System.out.println("Removed value: " + value);

    System.out.println("Updated HashMap: " + languages);
  }
}

Sortie

HashMap: {1=Java, 2=Python, 3=JavaScript}
Removed value: Python
Updated HashMap: {1=Java, 3=JavaScript}

Ici, le remove() la méthode prend la clé comme paramètre. Il renvoie ensuite la valeur associé à la clé et supprime l'entrée .

Nous pouvons également supprimer l'entrée uniquement sous certaines conditions. Par exemple,

remove(2, "C++");

Ici, le remove() la méthode supprime uniquement l'entrée si la touche 2 est associé à la valeur C++ . Depuis 2 n'est pas associé à C++ , cela ne supprime pas l'entrée.

Pour en savoir plus, visitez Java HashMap remove().

Autres méthodes de HashMap

Méthode	Description
effacer()	supprime tous les mappages du `HashMap`
calculer()	calcule une nouvelle valeur pour la clé spécifiée
computeIfAbsent()	calcule la valeur si un mappage pour la clé n'est pas présent
computeIfPresent()	calcule une valeur pour le mappage si la clé est présente
merge()	fusionne le mappage spécifié avec le `HashMap`
cloner()	fait la copie du `HashMap`
containsKey()	vérifie si la clé spécifiée est présente dans Hashmap
containsValue()	vérifie si `Hashmap` contient la valeur spécifiée
taille()	renvoie le nombre d'éléments dans `HashMap`
isEmpty()	vérifie si le `Hashmap` est vide

Itérer dans un HashMap

Pour parcourir chaque entrée du hashmap, nous pouvons utiliser la boucle Java for-each. Nous pouvons parcourir les clés uniquement , valles uniquement , et mappage clé/valeur . Par exemple,

import java.util.HashMap;
import java.util.Map.Entry;

class Main {
  public static void main(String[] args) {

    // create a HashMap
    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // iterate through keys only
    System.out.print("Keys: ");
    for (Integer key : languages.keySet()) {
      System.out.print(key);
      System.out.print(", ");
    }

    // iterate through values only
    System.out.print("\nValues: ");
    for (String value : languages.values()) {
      System.out.print(value);
      System.out.print(", ");
    }
    
    // iterate through key/value entries
    System.out.print("\nEntries: ");
    for (Entry<Integer, String> entry : languages.entrySet()) {
      System.out.print(entry);
      System.out.print(", ");
    }
  }
}

Sortie

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: 1, 2, 3,
Values: Java, Python, JavaScript,        
Entries: 1=Java, 2=Python, 3=JavaScript,

Notez que nous avons utilisé le Map.Entry dans l'exemple ci-dessus. C'est la classe imbriquée du Map interface qui renvoie une vue (éléments) de la carte.

Nous devons d'abord importer le java.util.Map.Entry package afin d'utiliser cette classe.

Cette classe imbriquée renvoie une vue (éléments) de la carte.

Création de HashMap à partir d'autres cartes

En Java, nous pouvons également créer un hashmap à partir d'autres cartes. Par exemple,

import java.util.HashMap;
import java.util.TreeMap;

class Main {
  public static void main(String[] args) {

    // create a treemap
    TreeMap<String, Integer> evenNumbers = new TreeMap<>();
    evenNumbers.put("Two", 2);
    evenNumbers.put("Four", 4);
    System.out.println("TreeMap: " + evenNumbers);

    // create hashmap from the treemap
    HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
    numbers.put("Three", 3);
    System.out.println("HashMap: " + numbers);
  }
}

Sortie

TreeMap: {Four=4, Two=2}
HashMap: {Two=2, Three=3, Four=4}

Dans l'exemple ci-dessus, nous avons créé un TreeMap nommé evenNumbers . Remarquez l'expression,

numbers = new HashMap<>(evenNumbers)

Ici, nous créons un HashMap numéros nommés en utilisant le TreeMap . Pour en savoir plus sur le treemap, visitez Java TreeMap.

Remarque :lors de la création d'un hashmap, nous pouvons inclure des paramètres facultatifs :capacity et facteur de charge . Par exemple,

HashMap<K, V> numbers = new HashMap<>(8, 0.6f);

Ici,

8 (la capacité est de 8) - Cela signifie qu'il peut stocker 8 entrées.
0.6f (le facteur de charge est de 0,6) - Cela signifie que chaque fois que notre table de hachage est remplie à 60 %, les entrées sont déplacées vers une nouvelle table de hachage deux fois plus grande que la table de hachage d'origine.

Si les paramètres facultatifs ne sont pas utilisés, la capacité par défaut aura 16 et le facteur de charge par défaut sera 0,75 .

Interface de carte Java Java LinkedHashMap

Java