How to Pretty-Print a Map in Java

1. Introduction

Pretty-printing a Map in Java involves formatting and displaying the key-value pairs of the map in a visually appealing and readable manner. While Java doesn’t provide a built-in method for pretty-printing maps, we have to implement a custom solution.

In this tutorial, we’ll learn how to achieve this goal. Depending on our preferences and the level of detail, we’ll explore multiple approaches, using only standard JDK and then external libraries.

2. Creating a Map

Before we move on, let’s create a map to work with:

Map<String, Object> map = Map.of(
  "one", 1,
  "two", 2,
  "inner", Map.of(
    "ten", 10,
    "eleven", 11
  )
);

Notably, we’ve extended our example by adding an inner nested map.

3. Using Core Java

As we know, Java can print maps using a built-in toString() method:

{one=1, two=2, inner={eleven=11, ten=10}}

The output is preformatted in a simple way, displaying key-value pairs separated by commas on a single line. It works fine for simple maps or during debugging.

But if we want a pretty-printed map, we have to implement custom methods.

3.1. Using a for-each Loop

When we need to iterate over all the elements, we can use a for-each loop:

for (Map.Entry<?, ?> entry : map.entrySet()) {
     System.out.printf("%-15s : %s%n", entry.getKey(), entry.getValue());
}

This loop will print:

one             : 1
two             : 2
inner           : {ten=10, eleven=11}

The output looks better now, but our inner map still isn’t pretty-printed, so we have to manually handle complex structures.

To format our inner entries, let’s implement a helper function with a recursion and a left padding parametrized:

void printMap(int leftPadding, Map<?, ?> map) {
    for (Map.Entry<?, ?> entry : map.entrySet()) {
        if (entry.getValue() instanceof Map) {
            System.out.printf("%-15s :%n", entry.getKey());
            printMap(leftPadding + 4, (Map<?, ?>) entry.getValue());
        }
        else {
            System.out.printf("%" + (leftPadding > 0 ? leftPadding : "") + "s" // adding padding
              + "%-15s : %s%n",
              "", entry.getKey(), entry.getValue());
        }
    }
}

Now, if we execute the method by calling printMap(0, map), it’ll print:

one             : 1
two             : 2
inner           :
    ten             : 10
    eleven          : 11

By implementing our custom solution, we’ll always have full control while printing our maps. We can customize our output by using built-in formatters such as the Formatter class, String.format(), or even System.out.printf(). On the other hand, a custom function might be a bit complicated if we’d like to handle multi-type or inner structures.

3.2. Using Stream

In Java, we can replace almost any for-each loop with a Stream. We can use one line to print and format our map:

map.forEach((k, v) -> System.out.printf("%-15s : %s%n", k, v));

If we want more control, we can expand the stream and use map() or Collectors.joining() functions:

System.out.println(MAP.entrySet().stream()
  .map(entry -> String.format("%-15s : %s", entry.getKey(), entry.getValue()))
  .collect(Collectors.joining("\n")));

In both examples, we’ll get:

one             : 1
two             : 2
inner           : {ten=10, eleven=11}

Once again, this approach gives us more control over formatting and works great for simple types. We must remember to manually handle any complex structures, as we did previously.

4. External Libraries

Implementing a custom pretty-print feature might be a good choice if we don’t have a complex map. Any additional mappings will make our code more complicated and not worth implementing. Let’s check the solutions provided by external libraries.

4.1. Jackson

If we compare JSON and map, we can find many similarities. In both cases, key-value pairs are used to represent entries.

First, let’s inspect Jackson, one of the most popular JSON libraries, by including its dependency in our pom.xml:

<dependency> 
    <groupId>com.fasterxml.jackson.core</groupId> 
    <artifactId>jackson-databind</artifactId> 
    <version>2.16.1</version>
</dependency>

Jackson provides an ObjectMapper class that can be used not only to work with JSON but also with standard maps:

String json = new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(map);

As a result, Jackson API pretty-prints our map:

{
  "one" : 1,
  "two" : 2,
  "inner" : {
    "ten" : 10,
    "eleven" : 11
  }
}

This solution automatically handles our inner map, and it’s much simpler than previous ones. Unfortunately, we don’t have full control over the mapping.

4.2. Gson

Of course, other JSON libraries also support maps for pretty-printing. Let’s check out Gson by adding the latest version of its dependency:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

Just like we did previously, let’s configure a GsonBuilder:

String json = new GsonBuilder().setPrettyPrinting().create().toJson(MAP);

And here’s the result now:

{
  "one": 1,
  "two": 2,
  "inner": {
    "ten": 10,
    "eleven": 11
  }
}

Notably, we have slightly different formatting (no space after the key), but again, it’s much easier to pretty-print maps supporting nested values.

4.3. Apache Commons Collections

When we know that JSON libraries often support JSON and maps for pretty-printing, let’s explore other solutions provided by non-JSON libraries.

Let’s check out Apache Commons Collections by adding a dependency to our project:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.5.0-M2</version>
</dependency>

The library brings us the MapUtils class. Let’s use it to print our map:

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

As a result, we’ll get the map formatted like this:

map = 
{
    one = 1 java.lang.Integer
    two = 2 java.lang.Integer
    inner = 
    {
        ten = 10 java.lang.Integer
        eleven = 11 java.lang.Integer
    } java.util.HashMap
} java.util.HashMap

We’ve just used a debugPrint() method to format the map. If we want to omit the class name of our values, we can use a verbosePrint().

4.4. Google Guava

Finally, let’s check out the approach provided by the Google Guava library. Before starting, let’s update our pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
</dependency>

To print our map, we can use the Joiner class:

String mapStr = Joiner.on(",\n").withKeyValueSeparator("=").join(map);

If we now check the result, we’ll get:

one=1,
two=2,
inner={ten=10, eleven=11}

Unfortunately, this approach can’t handle nested entries, but it works well for single-level structures.

5. Conclusion

In this article, we learned different approaches to pretty-print maps in Java. As we know, printing using the built-in toString() method can result in an unreadable, single-line string.

We started by implementing the custom pretty-print methods using standard Java API, especially the for-each loops, streams, and formatters. This approach suits us if we have simple, non-nested maps or want full control over the mapping.

After that, we inspected the solutions provided by external libraries like Jackson, Gson, Apache Commons Collections, or Guava. An external API is always simpler than implementing the custom solution, but we have less control over the predefined print format.