Pretty-imprimir un mapa en Java

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

Echa un vistazo a la biblioteca de Guayaba:

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

¡Bibliotecas Apache al rescate!

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

Todo lo que necesita Apache commons-collections library (project link)

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>

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

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

(esto sangra maravillosamente listas, conjuntos y mapas que pueden anidarse)

Simple y fácil. Bienvenido al mundo JSON. Usando el Gson de Google :

new Gson().toJson(map)

Ejemplo de mapa con 3 teclas:

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

Prefiero convertir el mapa a una cadena JSON que es:

• un estándar
• legible por humanos
• compatible con editores como Sublime, VS Code, con sintaxis resaltado, formato y sección hide/show
• soporta JPath para que los editores puedan informar exactamente qué parte del objeto usted ha navegado a

• Soporta 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 "";
  }
  

Mira 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(", ");
        }
    }
}

Así que si los chicos de OpenJDK no encontraron una manera más elegante de hacer esto, no hay ninguna: -)

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);

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);
}

Usted debe ser capaz de hacer lo que quiere haciendo:

System.out.println(map) por ejemplo

Siempre y cuando TODOS sus objetos en el mapa tengan overiden el método toString que verá:
{key1=value1, key2=value2} de una manera significativa

Si esto es para su código, entonces overiding toString es un buen hábito y le sugiero que vaya por eso en su lugar.

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

Supongo que algo como esto sería más limpio y le proporcionaría más flexibilidad con el formato de salida (simplemente cambie 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 alternativas como la en esta solución o manualmente usando un iterador.

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

No responde exactamente a la pregunta, pero vale la pena mencionar Lombodok @ToString anotación . Si anota con @ToString las clases key / value, entonces hacer System.out.println(map) devolverá algo significativo.

También funciona muy bien con mapas de mapas, por ejemplo: Map<MyKeyClass, Map<String, MyValueClass>> se imprimirá como

{MyKeyClass(properties...)={string1=MyValuesClass(properties...), string2=MyValuesCalss(properties...),..}, ... }