lista - Bonita impresión de un mapa en Java

mapas con java

Question

Estoy buscando una buena manera de imprimir un Map .

map.toString() me da: {key1=value1, key2=value2, key3=value3}

Quiero más libertad en los valores de entrada de mi mapa y estoy buscando algo como esto: key1="value1", key2="value2", key3="value3"

Escribí este pequeño código:

StringBuilder sb = new StringBuilder();
Iterator<Entry<String, String>> iter = map.entrySet().iterator();
while (iter.hasNext()) {
    Entry<String, String> entry = iter.next();
    sb.append(entry.getKey());
    sb.append(''='').append(''"'');
    sb.append(entry.getValue());
    sb.append(''"'');
    if (iter.hasNext()) {
        sb.append('','').append('' '');
    }
}
return sb.toString();

Pero estoy seguro de que hay una manera más elegante y concisa de hacer esto.

Answer 1

¡Bibliotecas de Apache al rescate!

MapUtils.debugPrint(System.out, "myMap", map);

Todo lo que necesitas biblioteca de colecciones comunes de Apache ( enlace del proyecto )

Los usuarios de Maven pueden agregar la biblioteca usando esta dependencia:

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.1</version>
</dependency>

Answer 2

Como una solución rápida y sucia que aprovecha la infraestructura existente, puede envolver su uglyPrintedMap en un java.util.HashMap , luego usar toString() .

uglyPrintedMap.toString(); // ugly
System.out.println( uglyPrintedMap ); // prints in an ugly manner

new HashMap<Object, Object>(jobDataMap).toString(); // pretty
System.out.println( new HashMap<Object, Object>(uglyPrintedMap) ); // prints in a pretty manner

Answer 3

Cuando tengo org.json.JSONObject en classpath, hago:

Map<String, Object> stats = ...;
System.out.println(new JSONObject(stats).toString(2));

(Esto maravillosamente sangra las listas, conjuntos y mapas que pueden estar anidados)

Answer 4

Debería poder hacer lo que quiera haciendo:

System.out.println(map) por ejemplo

Siempre y cuando TODOS los objetos en el mapa hayan superado el método toString , verás lo siguiente:
{key1=value1, key2=value2} de una manera significativa

Si esto es por tu código, entonces reemplazar a String es un buen hábito y te sugiero que vayas por eso.

Para su ejemplo, donde sus objetos son String , debería estar bien sin nada más.
Es decir, System.out.println(map) imprimiría exactamente lo que necesita sin ningún código adicional

Answer 5

Eche un vistazo a la biblioteca de Guava:

Joiner.MapJoiner mapJoiner = Joiner.on(",").withKeyValueSeparator("=");
System.out.println(mapJoiner.join(map));

Answer 6

Mire el código para HashMap#toString() y AbstractMap#toString() en las fuentes de OpenJDK:

class java.util.HashMap.Entry<K,V> implements Map.Entry<K,V> {
       public final String toString() {
           return getKey() + "=" + getValue();
       }
   }
 class java.util.AbstractMap<K,V> {
     public String toString() {
         Iterator<Entry<K,V>> i = entrySet().iterator();
         if (! i.hasNext())
            return "{}";

        StringBuilder sb = new StringBuilder();
        sb.append(''{'');
        for (;;) {
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key);
            sb.append(''='');
            sb.append(value == this ? "(this Map)" : value);
            if (! i.hasNext())
                return sb.append(''}'').toString();
            sb.append(", ");
        }
    }
}

Entonces, si los chicos de OpenJDK no encontraron una forma más elegante de hacerlo, no hay ninguno :-)

Answer 7

O pon tu lógica en una pequeña clase ordenada.

public class PrettyPrintingMap<K, V> {
    private Map<K, V> map;

    public PrettyPrintingMap(Map<K, V> map) {
        this.map = map;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        Iterator<Entry<K, V>> iter = map.entrySet().iterator();
        while (iter.hasNext()) {
            Entry<K, V> entry = iter.next();
            sb.append(entry.getKey());
            sb.append(''='').append(''"'');
            sb.append(entry.getValue());
            sb.append(''"'');
            if (iter.hasNext()) {
                sb.append('','').append('' '');
            }
        }
        return sb.toString();

    }
}

Uso:

Map<String, String> myMap = new HashMap<String, String>();

System.out.println(new PrettyPrintingMap<String, String>(myMap));

Nota: También puede poner esa lógica en un método de utilidad.

Answer 8

Prefiero convertir el mapa a una cadena JSON, es decir:

• un estandar
• humano legible
• compatible con editores como Sublime, VS Code, con resaltado de sintaxis, formato y sección hide / show
• admite JPath para que los editores puedan informar exactamente a qué parte del objeto ha navegado

• admite tipos complejos anidados dentro del objeto

  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.databind.ObjectMapper;
  
  public static String getAsFormattedJsonString(Object object)
  {
      ObjectMapper mapper = new ObjectMapper();
      try
      {
          return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
      }
      catch (JsonProcessingException e)
      {
          e.printStackTrace();
      }
      return "";
  }

Answer 9

Simple y fácil. Bienvenido al mundo JSON. Usando Google''s Gson :

new Gson().toJson(map)

Ejemplo de mapa con 3 claves:

{"array":[null,"Some string"],"just string":"Yo","number":999}

Answer 10

Supongo que algo así sería más limpio y te proporcionaría más flexibilidad con el formato de salida (simplemente cambia la plantilla):

    String template = "%s=/"%s/",";
    StringBuilder sb = new StringBuilder();
    for (Entry e : map.entrySet()) {
        sb.append(String.format(template, e.getKey(), e.getValue()));
    }
    if (sb.length() > 0) {
        sb.deleteCharAt(sb.length() - 1); // Ugly way to remove the last comma
    }
    return sb.toString();

Sé que tener que eliminar la última coma es feo, pero creo que es más limpio que las alternativas como la de esta solución o manualmente usando un iterador.

Answer 11

Usando Java 8 Streams:

Map<Object, Object> map = new HashMap<>();

String content = map.entrySet()
                    .stream()
                    .map(e -> e.getKey() + "=/"" + e.getValue() + "/"")
                    .collect(Collectors.joining(", "));

System.out.println(content);

Answer 12

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

Answer 13

public void printMapV2 (Map <?, ?> map) {
    StringBuilder sb = new StringBuilder(128);
    sb.append("{");
    for (Map.Entry<?,?> entry : map.entrySet()) {
        if (sb.length()>1) {
            sb.append(", ");
        }
        sb.append(entry.getKey()).append("=").append(entry.getValue());
    }
    sb.append("}");
    System.out.println(sb);
}