Impression de HashMap en Java

J'ai un HashMap:

private HashMap<TypeKey, TypeValue> example = new HashMap<TypeKey, TypeValue>();

Je voudrais maintenant parcourir toutes les valeurs et les imprimer.

J'ai écrit ceci:

for (TypeValue name : this.example.keySet()) {
    System.out.println(name);
}

Cela ne semble pas fonctionner.

Quel est le problème?

EDIT: Une autre question: cette collection est-elle basée sur zéro? Je veux dire que s'il a 1 clé et la valeur, la taille sera-t-elle 0 ou 1?

keySet () ne renvoie qu'un ensemble de clés de votre hashmap, vous devez itérer cet ensemble de clés et obtenir la valeur de la hashmap en utilisant ces clés.

Dans votre exemple, le type de la clé du hashmap est TypeKey, mais vous l'avez spécifié TypeValuedans votre boucle for générique, il ne peut donc pas être compilé. Vous devriez le changer en:

for (TypeKey name: example.keySet()){
            String key = name.toString();
            String value = example.get(name).toString();  
            System.out.println(key + " " + value);  
} 

Mise à jour pour Java8:

 example.entrySet().forEach(entry->{
    System.out.println(entry.getKey() + " " + entry.getValue());  
 });

Si vous n'avez pas besoin d'imprimer la valeur de la clé et avez simplement besoin de la valeur de hashmap, vous pouvez utiliser les suggestions des autres.

Une autre question: cette collection est-elle à base zéro? Je veux dire que s'il a 1 clé et sa valeur, sa taille sera-t-elle 0 ou 1?

La collection renvoyée par keySet()est un ensemble. Vous ne pouvez pas obtenir la valeur d'un ensemble à l'aide d'un index, il ne s'agit donc pas de savoir s'il est basé sur zéro ou sur un. Si votre hashmap a une clé, le keySet () retourné aura une entrée à l'intérieur, et sa taille sera 1.

Un moyen simple de voir les paires valeur / clé:

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
System.out.println(Arrays.asList(map)); // method 1
System.out.println(Collections.singletonList(map)); // method 2

La méthode 1 et la méthode 2 affichent ceci:

[{b=2, a=1}]

En supposant que vous ayez un Map<KeyType, ValueType>, vous pouvez l'imprimer comme ceci:

for (Map.Entry<KeyType, ValueType> entry : map.entrySet()) {
    System.out.println(entry.getKey()+" : "+entry.getValue());
}

Pour imprimer à la fois la clé et la valeur, utilisez ce qui suit:

for (Object objectName : example.keySet()) {
   System.out.println(objectName);
   System.out.println(example.get(objectName));
 }

Vous avez plusieurs options

• Get map.values(), qui obtient les valeurs, pas les clés
• Obtenez le map.entrySet()qui a les deux
• Obtenez le keySet()et pour chaque appel de touchemap.get(key)

Vous voulez que la valeur soit définie, pas l'ensemble de clés:

for (TypeValue name: this.example.values()) {
        System.out.println(name);
}

Le code que vous donnez ne serait même pas compilé, ce qui pourrait valoir la peine d'être mentionné dans les prochaines questions - «ne semble pas fonctionner» est un peu vague!

Il convient de mentionner l'approche Java 8, utilisant BiConsumerles fonctions et lambda:

BiConsumer<TypeKey, TypeValue> consumer = (o1, o2) -> 
           System.out.println(o1 + ", " + o2);

example.forEach(consumer);

En supposant que vous ayez remplacé la toStringméthode des deux types si nécessaire.

Pour moi, cette simple ligne a bien fonctionné:

Arrays.toString(map.entrySet().toArray())

Une simple instruction d'impression avec le nom de variable qui contient la référence de la carte de hachage ferait:

HashMap<K,V> HM = new HashMap<>(); //empty
System.out.println(HM); //prints key value pairs enclosed in {}

Cela fonctionne car la toString()méthode est déjà remplacée dans le AbstractMap classqui est étendu par le HashMap Class Plus d'informations de la documentation

Renvoie une représentation sous forme de chaîne de cette carte. La représentation sous forme de chaîne consiste en une liste de mappages clé-valeur dans l'ordre renvoyé par l'itérateur de la vue entrySet de la carte, entre accolades ("{}"). Les mappages adjacents sont séparés par les caractères "," (virgule et espace). Chaque mappage clé-valeur est rendu comme la clé suivie d'un signe égal ("=") suivi de la valeur associée. Les clés et les valeurs sont converties en chaînes comme par String.valueOf (Object).

Nouveau forEachstyle de fonctionnalité Java 8

import java.util.HashMap;

public class PrintMap {
    public static void main(String[] args) {
        HashMap<String, Integer> example = new HashMap<>();
        example.put("a", 1);
        example.put("b", 2);
        example.put("c", 3);
        example.put("d", 5);

        example.forEach((key, value) -> System.out.println(key + " : " + value));

//      Output:
//      a : 1
//      b : 2
//      c : 3
//      d : 5

    }
}

Je l'ai fait en utilisant String Map (si vous travaillez avec String Map).

for (Object obj : dados.entrySet()) {
    Map.Entry<String, String> entry = (Map.Entry) obj;
    System.out.print("Key: " + entry.getKey());
    System.out.println(", Value: " + entry.getValue());
}

map.forEach((key, value) -> System.out.println(key + " " + value));

Utilisation des fonctionnalités de Java 8

Utile pour imprimer rapidement des entrées dans un HashMap

System.out.println(Arrays.toString(map.entrySet().toArray()));

Si la carte contient une collection comme valeur, les autres réponses nécessitent un effort supplémentaire pour les convertir en chaînes, telles que Arrays.deepToString(value.toArray()) (s'il s'agit d'une carte de valeurs de liste), etc.

J'ai rencontré ces problèmes assez souvent et suis tombé sur la fonction générique pour imprimer tous les objets en utilisant ObjectMappers. C'est assez pratique à tous les endroits, en particulier lors de l'expérimentation, et je vous recommande de choisir cette façon.

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public static String convertObjectAsString(Object object) {
    String s = "";
    ObjectMapper om = new ObjectMapper();
    try {
        om.enable(SerializationFeature.INDENT_OUTPUT);
        s = om.writeValueAsString(object);
    } catch (Exception e) {
        log.error("error converting object to string - " + e);
    }
    return s;
}

Vous pouvez utiliser la Entryclasse pour lire HashMapfacilement.

for(Map.Entry<TypeKey, TypeKey> temp : example.entrySet()){
    System.out.println(temp.getValue()); // Or something as per temp defination. can be used
}