What's the simplest way to print a Java array?

The Simplest Ways to Print a Java Array

Discover various straightforward methods to print the contents of a Java array, from basic loops to utility class functions, ensuring clear and readable output.

Printing the contents of a Java array is a common task for debugging, logging, or displaying information to users. While it might seem trivial, simply calling System.out.println() on an array object doesn't produce the human-readable output you might expect. Instead, you'll typically get a memory address. This article explores the simplest and most effective ways to print Java arrays, covering primitive types, objects, and multi-dimensional arrays.

Understanding Default Array Printing

When you try to print a Java array directly using System.out.println(myArray);, Java's default toString() method for arrays (inherited from Object) is invoked. This method doesn't iterate through the array elements. Instead, it returns a string representation consisting of the array's type, followed by an '@' symbol, and then the array's hash code in hexadecimal. This output is rarely useful for understanding the array's contents.

public class ArrayPrintExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println(numbers); // Output: [I@15db9742 (or similar)

        String[] names = {"Alice", "Bob", "Charlie"};
        System.out.println(names);   // Output: [Ljava.lang.String;@6d06d69c (or similar)
    }
}

Default output when printing a Java array directly

Printing Arrays with Arrays.toString()

For single-dimensional arrays, the java.util.Arrays.toString() method is by far the simplest and most recommended approach. It returns a string representation of the array's contents, enclosed in square brackets [], with elements separated by commas and spaces. This method works for all primitive types and object arrays.

import java.util.Arrays;

public class ArraysToStringExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println(Arrays.toString(numbers)); // Output: [10, 20, 30, 40, 50]

        String[] fruits = {"Apple", "Banana", "Cherry"};
        System.out.println(Arrays.toString(fruits)); // Output: [Apple, Banana, Cherry]

        double[] prices = {1.99, 2.49, 0.75};
        System.out.println(Arrays.toString(prices)); // Output: [1.99, 2.49, 0.75]
    }
}

Using Arrays.toString() for single-dimensional arrays

Printing Multi-Dimensional Arrays with Arrays.deepToString()

When dealing with multi-dimensional arrays (arrays of arrays), Arrays.toString() will only print the memory addresses of the inner arrays. To get a complete, human-readable representation of all elements in a multi-dimensional array, you should use java.util.Arrays.deepToString().

import java.util.Arrays;

public class ArraysDeepToStringExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // Incorrect for multi-dimensional arrays:
        System.out.println("Using toString(): " + Arrays.toString(matrix)); 
        // Output: Using toString(): [[I@15db9742, [I@6d06d69c, [I@7852e922]

        // Correct for multi-dimensional arrays:
        System.out.println("Using deepToString(): " + Arrays.deepToString(matrix));
        // Output: Using deepToString(): [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    }
}

Using Arrays.deepToString() for multi-dimensional arrays

flowchart TD
    A[Start]
    B{Is array single-dimensional?}
    C[Use Arrays.toString()]
    D[Use Arrays.deepToString()]
    E[End]

    A --> B
    B -- Yes --> C
    B -- No --> D
    C --> E
    D --> E

Decision flow for printing Java arrays

Manual Iteration (Looping) for Custom Formatting

While Arrays.toString() and Arrays.deepToString() are excellent for quick and standard output, you might sometimes need more control over the formatting. In such cases, a simple loop (for-loop or enhanced for-loop) allows you to iterate through each element and print it exactly as desired.

public class ManualArrayPrintExample {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue"};

        System.out.print("Colors: ");
        for (int i = 0; i < colors.length; i++) {
            System.out.print(colors[i]);
            if (i < colors.length - 1) {
                System.out.print(" | "); // Custom separator
            }
        }
        System.out.println(); // New line at the end

        // Enhanced for-loop for simpler iteration
        System.out.print("Numbers (enhanced loop): ");
        int[] numbers = {100, 200, 300};
        for (int num : numbers) {
            System.out.print("(" + num + ") ");
        }
        System.out.println();
    }
}

Printing arrays using manual loops for custom formatting