How to Print a Java Array: Arrays.toString() and Arrays.deepToString()

By the end of this page, you will understand why Java arrays do not print their contents automatically, how to use Arrays.toString() for normal arrays, and when to use Arrays.deepToString() for nested arrays.

Java arrays are objects, but they do not provide a custom toString() implementation that lists their elements. That means when you print an array directly, Java falls back to Object.toString().

That default representation typically looks like this:

[I@3343c8b3

This value is not the array contents. It is a low-level object description:

• [I means "array of int"
• @ separates the type from the hash code
• 3343c8b3 is the object's hash code in hexadecimal

To print the actual values, Java provides utility methods in the java.util.Arrays class.

The most common one is:

Arrays.toString(array)

This returns a readable string version of a one-dimensional array.

Example:

int[] numbers = {1, 2, 3};
System.out.println(Arrays.toString(numbers));

Output:

[1, , ]

Think of an array like a box full of items.

• Printing the array directly is like reading the box's shipping label.
• Using Arrays.toString() is like opening the box and listing what's inside.
• Using Arrays.deepToString() is like opening smaller boxes inside the big box too.

So:

• System.out.println(array) shows the container identity
• Arrays.toString(array) shows the items
• Arrays.deepToString(array) shows items, including inside nested arrays

The simplest syntax is:

import java.util.Arrays;

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

Example 1: Primitive array

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] intArray = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(intArray));
    }
}

Output:

[1, 2, 3, 4, 5]

Arrays.toString() works with primitive arrays such as:

• int[]
• double[]
• char[]
• boolean[]

Example 2: Object array

Consider this code:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] values = {10, 20, 30};
        String result = Arrays.toString(values);
        System.out.println(result);
    }
}

Here is what happens step by step:

1. int[] values = {10, 20, 30};

   • Java creates an integer array with three elements.
   • The array holds 10, 20, and 30.

2. String result = Arrays.toString(values);

   • The Arrays utility class reads each element in the array.
   • It builds a new string in this format:

     [10, 20, ]
     

Readable array printing is useful in many practical situations:

Debugging program state

int[] scores = {85, 90, 78};
System.out.println(Arrays.toString(scores));

You can quickly verify that your logic produced the expected values.

Logging API or user input data

String[] tags = {"java", "arrays", "debugging"};
System.out.println("Tags: " + Arrays.toString(tags));

This makes logs understandable.

Testing and assertions

When a test fails, readable array output helps compare expected and actual values.

System.out.println("Expected: [1, 2, 3]");
System.out.println("Actual:   " + Arrays.toString(actual));

Data processing scripts

If you transform arrays in a batch job, printing results after each step helps validate the pipeline.

Working with matrices or grid data

For two-dimensional arrays, Arrays.deepToString() is useful when inspecting table-like data such as game boards, seating layouts, or numeric matrices.

In real projects, developers usually do not print arrays directly. They use utility methods to make logs and debugging output readable.

Common patterns include:

Logging computed values

import java.util.Arrays;

int[] filtered = {2, 4, 6};
System.out.println("Filtered values: " + Arrays.toString(filtered));

Guarding against null

Arrays.toString(null) is safe and returns the string "null", but teams often still make the intent explicit.

import java.util.Arrays;

String[] names = null;
System.out.println(names == null ? "No names provided" : Arrays.toString(names));

Printing nested configuration data

import java.util.Arrays;

String[][] roles = {
    {"admin", "editor"},
    {"viewer"}
};

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

Combining with validation

import java.util.Arrays;

[] values = {, , };
 (values.length == ) {
    System.out.println();
    ;
}

System.out.println(Arrays.toString(values));

1. Printing the array directly

Broken code:

int[] numbers = {1, 2, 3};
System.out.println(numbers);

Problem:

• This prints something like [I@1a2b3c4d.
• It shows object information, not the contents.

Fix:

import java.util.Arrays;

System.out.println(Arrays.toString(numbers));

2. Forgetting to import Arrays

Broken code:

System.out.println(Arrays.toString(numbers));

Problem:

• Without import java.util.Arrays;, the code will not compile unless you use the fully qualified name.

Fix:

import java.util.Arrays;

Or:

System.out.println(java.util.Arrays.toString(numbers));

3. Using Arrays.toString() for nested arrays

import java.util.Arrays;

Print a one-dimensional array

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

Examples:

int[] a = {1, 2, 3};
System.out.println(Arrays.toString(a)); // [1, 2, 3]

String[] names = {"John", "Mary"};
System.out.println(Arrays.toString(names)); // [John, Mary]

Print a nested array

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

Example:

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

Avoid this for readable output

System.out.println(array);

Quick rules

• Arrays.toString() → one-dimensional arrays

Why does Java print [I@... for an int[]?

Because arrays use the default Object.toString() output instead of showing their elements.

What is the simplest way to print a Java array?

Use Arrays.toString(array) for a normal one-dimensional array.

How do I print a 2D array in Java?

Use Arrays.deepToString(array) for arrays that contain other arrays.

Do I need to import anything to print arrays nicely?

Yes. Usually you import:

import java.util.Arrays;

Does Arrays.toString() work for both primitive and object arrays?

Yes. It works for arrays like int[], double[], and String[].

Can I print an array without Arrays.toString()?

Yes, by writing a loop yourself, but that is usually more code and only needed for custom formatting.

Why does ArrayList print nicely but arrays do not?

• Java arrays — Arrays are the core data structure involved in this question.
• Object.toString() — Understanding the default string representation explains why arrays print strangely.
• java.util.Arrays — This utility class provides toString() and deepToString().
• Multidimensional arrays in Java — Important because nested arrays require Arrays.deepToString().
• ArrayList in Java — Useful for comparing how collections print differently from arrays.
• Debugging in Java — Printing readable values is a common debugging technique.
• Java Streams — Helpful when you want custom formatted output beyond the default bracketed style.