Arrays.deepToString() Method in Java

The Arrays.deepToString() method in Java returns a string representation of a multidimensional array: it recursively walks through the nested arrays and wraps every level in square brackets. It is the shortest way to print a 2D or multidimensional array to the console without writing loops. The method is declared in the java.util.Arrays class:

public static String deepToString(Object[] a)

Example: converting a 2D array to a string

Pass a two-dimensional String array to the method — Arrays.deepToString() returns the contents of both nesting levels:

import java.util.Arrays;

public class ArraysDeepToStringExample {
    public static void main(String[] args) {
        String[][] array = {{"one-one", "one-two", "one-three"},
                {"two-one", "two-two", "two-three"}};
        System.out.println(Arrays.deepToString(array));
    }
}

Program output:

[[one-one, one-two, one-three], [two-one, two-two, two-three]]

The outer brackets represent the whole array, the inner ones represent each of its rows. The method works with any nesting depth: a three-dimensional array produces three levels of brackets, and so on. That makes it handy for debugging and for printing tables, matrices, and other nested structures.

Difference from Arrays.toString()

The Arrays class has a similar method — Arrays.toString(). It processes only the first level of the array: each element is converted by calling its own toString(). For a 2D array the first-level elements are the nested arrays themselves, and arrays do not override toString() — so instead of the contents you get the type and hash code:

String[][] array = {{"one-one", "one-two"}, {"two-one", "two-two"}};

System.out.println(Arrays.toString(array));
System.out.println(Arrays.deepToString(array));

Program output:

[[Ljava.lang.String;@1b6d3586, [Ljava.lang.String;@4554617c]
[[one-one, one-two], [two-one, two-two]]

Arrays of primitives

A two-dimensional array of primitives, such as int[][], can be passed to deepToString(): its first-level elements are objects of type int[], so the array is compatible with the Object[] parameter:

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(matrix));

Program output:

[[1, 2, 3], [4, 5, 6]]

null and self-referencing arrays

The method handles the edge cases that usually break a hand-written recursive printer:

• if the argument is null, the string "null" is returned;
• nested null elements are also printed as null;
• if the array directly or indirectly contains a reference to itself, "[...]" is printed in that place instead of infinite recursion.

Object[] selfRef = new Object[2];
selfRef[0] = "first";
selfRef[1] = selfRef; // the array references itself

System.out.println(Arrays.deepToString(selfRef));

Program output:

[first, [...]]

For comparing and hashing multidimensional arrays, the Arrays class offers companion methods with the same “deep” semantics — Arrays.deepEquals() and Arrays.deepHashCode().