¿Cómo descargo el contenido de un mapa hash?

Question

¿Cómo puedo volcar el contenido de un HashMap de Java (o de cualquier otro), por ejemplo, a STDOUT?

A modo de ejemplo, supongamos que tengo un HashMap complejo de la siguiente estructura:

(student1 => Map(name => Tim,   
        Scores => Map(math => 10, 
            physics => 20, 
            Computers => 30), 
        place => Miami, 
        ranking => Array(2,8,1,13), 
       ), 
student2 => Map ( 
        ............... 
        ............... 
       ), 
............................ 
............................ 
); 

Así que desea imprimir a la pantalla con el fin de tener una idea acerca de la estructura de datos. Estoy buscando algo similar a var_dump() de PHP o dumper de Perl().

Answer 1

Uso HashMap.toString() (docs here):

System.out.println("HASH MAP DUMP: " + myHashMap.toString()); 

general, el uso Object.toString() para volcar los datos de este tipo.

Answer 2

A menudo utilizo una función como esta (puede necesitar ser expandida para acomodar la impresión con prety de otros tipos de objetos dentro de Map).

@SuppressWarnings("unchecked") 
private static String hashPP(final Map<String,Object> m, String... offset) { 
    String retval = ""; 
    String delta = offset.length == 0 ? "" : offset[0]; 
    for(Map.Entry<String, Object> e : m.entrySet()) { 
     retval += delta + "["+e.getKey() + "] -> "; 
     Object value = e.getValue(); 
     if(value instanceof Map) { 
      retval += "(Hash)\n" + hashPP((Map<String,Object>)value, delta + " "); 
     } else if(value instanceof List) { 
      retval += "{"; 
      for(Object element : (List)value) { 
       retval += element+", "; 
      } 
      retval += "}\n"; 
     } else { 
      retval += "["+value.toString()+"]\n"; 
     } 
    } 
    return retval+"\n"; 
} // end of hashPP(...) 

Así siguiente código

public static void main(String[] cmd) { 
    Map<String,Object> document = new HashMap<String, Object>(); 

    Map<String,Object> student1 = new LinkedHashMap<String, Object>(); 
    document.put("student1", student1); 
    student1.put("name", "Bob the Student"); 
    student1.put("place", "Basement"); 
    List<Integer> ranking = new LinkedList<Integer>(); 
    student1.put("ranking", ranking); 
    ranking.add(2); 
    ranking.add(8); 
    ranking.add(1); 
    ranking.add(13); 
    Map<String,Object> scores1 = new HashMap<String, Object>(); 
    student1.put("Scores", scores1); 
    scores1.put("math", "0"); 
    scores1.put("business", "100"); 

    Map<String,Object> student2= new LinkedHashMap<String, Object>(); 
    document.put("student2", student2); 
    student2.put("name", "Ivan the Terrible"); 
    student2.put("place", "Dungeon"); 

    System.out.println(hashPP(document)); 
} 

producirá salida

[student2] -> (Hash) 
    [name] -> [Ivan the Terrible] 
    [place] -> [Dungeon] 

[student1] -> (Hash) 
    [name] -> [Bob the Student] 
    [place] -> [Basement] 
    [ranking] -> {2, 8, 1, 13, } 
    [Scores] -> (Hash) 
    [math] -> [0] 
    [business] -> [100] 

vez más. Es posible que deba modificar esto para sus necesidades particulares.

Answer 3

Una buena forma de volcar estructuras de datos (por ejemplo, de mapas anidados, matrices y conjuntos) es serializándola en formato JSON. Por ejemplo, usando Gson (com.google.gson):

Gson gson = new GsonBuilder().setPrettyPrinting().create(); 
System.out.println(gson.toJson(dataStructure)); 

Esto imprimirá las estructuras de datos más complejas de una manera bastante fácil de leer.