Pause café #224. Comment parcourir un Hashmap à l'aide d'une boucle. Comprendre Void et Null en Java avec des exemples

Comment parcourir une Hashmap à l'aide d'une boucle

Source : FreeCodeCamp Ce didacticiel explique en détail comment parcourir un Hashmap en utilisant différents types de boucles en Java. Hashmap est une structure de données utilisée pour stocker des données dans des paires clé-valeur. Il est largement utilisé dans de nombreux langages de programmation, notamment Java, Python et JavaScript. Itérer sur une Hashmap est une opération courante que les développeurs effectuent souvent. Dans la plupart des cas, ses étapes sont assez simples. Vous lancez d’abord un Hashmap, puis utilisez un itérateur pour le parcourir et enfin affichez le résultat.

Comment parcourir une Hashmap en Java à l'aide d'une boucle For-each

L'un des moyens les plus simples de parcourir un Hashmap consiste à utiliser une boucle for-each . Voici un exemple de la façon de procéder :

HashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

Dans cet exemple, nous créons d’abord un nouveau Hashmap et y ajoutons des paires clé-valeur. Nous utilisons ensuite une boucle for-each pour parcourir le Hashmap , récupérant chaque paire clé-valeur en tant qu'objet Map.Entry . Nous extrayons ensuite la clé et la valeur de chaque objet Map.Entry et les imprimons sur la console.

Comment parcourir un Hashmap en Java en utilisant une boucle while avec un itérateur

Une autre façon de parcourir un Hashmap consiste à utiliser une boucle while avec un itérateur. Voici un exemple de la façon de procéder :

HashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

Ici, nous créons à nouveau un nouveau Hashmap et y ajoutons des paires clé-valeur. Nous créons ensuite un nouvel objet Iterator à l'aide de la méthode EntrySet() , qui renvoie un ensemble de paires clé-valeur sous forme d'objets Map.Entry . Nous utilisons ensuite une boucle while avec les méthodes hasNext() et next() pour parcourir l'ensemble et extraire chaque paire clé-valeur. Enfin, nous extrayons la clé et la valeur de chaque objet Map.Entry et les imprimons sur la console.

Comment parcourir un Hashmap Java en utilisant une boucle for avec keySet()

En Java, la méthode keySet() est une méthode de la classe java.util.HashMap qui renvoie une représentation définie des clés contenues dans le Hashmap . Cela signifie qu'il renvoie un ensemble de toutes les clés du Hashmap , qui peuvent être utilisées pour parcourir les clés ou effectuer d'autres opérations sur celles-ci. Le fait que la méthode keySet() renvoie un ensemble d'éléments uniques sans doublons est dû au fait que les clés d' un Hashmap doivent être uniques et que la méthode keySet() garantit que l'ensemble de clés qu'elle renvoie ne contient pas de valeurs en double. Nous pouvons également parcourir un Hashmap en utilisant une boucle for avec la méthode keySet() . Voici un exemple de la façon de procéder :

ashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

for (String key : map.keySet()) {
    Integer value = map.get(key);
    System.out.println("Key: " + key + ", Value: " + value);

Dans cet exemple, nous créons à nouveau un nouveau Hashmap et y ajoutons plusieurs paires clé-valeur. Nous utilisons ensuite une boucle for avec la méthode keySet() pour parcourir le Hashmap , en extrayant chaque clé et en l'utilisant pour obtenir la valeur correspondante du Hashmap . Nous imprimons ensuite la clé et la valeur sur la console.

Conclusion

Dans cet article, vous avez appris trois façons de parcourir une Hashmap en utilisant différents types de boucles. En suivant ces directives, vous pourrez mieux travailler avec Hashmap et d'autres structures de données. Veuillez noter que modifier le Hashmap au cours d'une itération peut produire des résultats inattendus, cela doit donc être évité si possible.

Comprendre Void et Null en Java avec des exemples

Source : Medium Ce guide vous apprendra les différences entre Void et Null , ainsi que quelques exemples d'utilisation. Il existe deux mots-clés très couramment utilisés dans le langage de programmation Java : Void et Null . Les deux sont utilisés pour indiquer une absence, mais dans des contextes différents. De plus, leur utilisation et leur comportement sont différents les uns des autres.

Vide

En Java, le mot-clé Void est utilisé pour indiquer l'absence d'une valeur. Il est généralement utilisé comme type de retour pour les méthodes qui ne renvoient pas de valeur. Les méthodes Void sont exécutées en raison de leurs effets secondaires, tels que l'impression de quelque chose sur la console ou la modification de l'état d'un objet. Voici un exemple de la méthode Void :

public void printMessage(String message) {
    System.out.println(message);
}

Dans cet exemple, la méthode printMessage prend un argument de chaîne nommé message et l'imprime sur la console à l'aide de la méthode System.out.println() . Le type de retour de la méthode est Void , ce qui signifie que la méthode ne renvoie pas de valeur.

Nul

Null est utilisé pour indiquer qu’il n’y a aucune référence à un objet. Il est couramment utilisé en Java pour initialiser des variables ou pour indiquer qu'un objet n'existe pas. Null n'est pas un mot-clé en Java, mais plutôt un mot réservé qui représente une valeur littérale pouvant être attribuée à n'importe quelle variable de référence d'objet. Voici un exemple d'utilisation de Null pour initialiser une variable :

String message = null;

Dans cet exemple, la variable message est initialisée à Null . Cela signifie qu’il ne pointe vers aucun objet en mémoire.

Quelles sont les différences entre Void et Null

La principale différence entre Void et Null est que Void représente l'absence de valeur, tandis que Null représente l'absence de référence d'objet. Void est utilisé pour déclarer des méthodes qui ne renvoient pas de valeur, tandis que Null est utilisé pour initialiser des variables ou pour indiquer qu'un objet n'existe pas. Une autre différence entre Void et Null est que Void est un mot-clé en Java et Null est un mot réservé. Void est également utilisé en Java pour déclarer des types génériques tels que Void<T> , qui représentent un type générique ne contenant aucune donnée. De plus, Void ne peut être utilisé que comme type de retour pour les méthodes, mais Null peut être attribué à n'importe quelle variable de référence d'objet.

Conclusion

Void et Null sont des concepts importants dans le langage de programmation Java. Void représente l'absence de valeur et est couramment utilisé comme type de retour pour les méthodes qui ne renvoient pas de valeur. Null , en revanche, représente l'absence de référence à un objet et est généralement utilisé pour initialiser des variables ou pour indiquer qu'un objet n'existe pas. En comprenant clairement la différence entre Void et Null , vous pouvez écrire du code plus efficace.