How to Print All Elements of an Array in Java

Printing the contents of an array feels like it should be trivial — and yet it’s one of the most common places where new Java developers get tripped up. Try System.out.println(myArray) directly, and instead of a nice readable list, you’ll get a cryptic string like [I@1b6d3586. This article walks through every practical way to print array elements in Java, explains why the naive approach fails, and gives you production-ready patterns for 1D arrays, 2D arrays, and everything in between.

Why Printing Arrays Isn’t as Simple as It Looks

In many languages, printing a list or array directly gives you a friendly, human-readable output. Java doesn’t do this by default because arrays don’t override the toString() method inherited from Object.

That means calling:

System.out.println(arr);

on an int[] prints something like:

[I@372f7a8d

—a mash-up of the type descriptor and the object’s hash code, not the actual contents.

This design decision trips up beginners constantly, which is exactly why Java provides several purpose-built tools — loops, the Arrays utility class, and streams — to solve the problem properly.

Method 1: Classic Indexed For Loop

This is the most fundamental and widely taught approach, and it’s essential to understand even if you rarely use it in production code, because it reveals exactly how array traversal works under the hood.

int[] numbers = {5, 10, 15, 20, 25};

System.out.println("Array elements are:");

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

Output

Array elements are:
5
10
15
20
25

Here, numbers.length returns the total element count (5), and the loop visits indices 0 through 4 in order, printing each value on its own line.

Method 2: Enhanced For Loop (For-Each)

Once you’re comfortable with the indexed loop, the enhanced for loop is a cleaner, less error-prone alternative for simple traversal (when you don’t need the index itself).

int[] numbers = {5, 10, 15, 20, 25};

for (int num : numbers) {
    System.out.println(num);
}

Output

5
10
15
20
25

This eliminates index-related bugs entirely (no off-by-one errors, no manual bounds checking) and is generally the preferred style for read-only traversal in professional codebases.

Method 3: Arrays.toString()

If you want to print the entire array on one line, in bracketed, comma-separated form — ideal for debugging or logging — the Arrays utility class is your best friend.

import java.util.Arrays;

int[] numbers = {5, 10, 15, 20, 25};

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

// Output:
// [5, 10, 15, 20, 25]

Output

[5, 10, 15, 20, 25]

This is by far the most common approach used in real production code for quick debugging output, log statements, and unit test assertions.

Method 4: Java Streams (Java 8+)

For more functional-style code, or when you want to transform elements while printing (e.g., formatting, filtering), streams offer a flexible approach.

import java.util.Arrays;

int[] numbers = {5, 10, 15, 20, 25};

Arrays.stream(numbers)
      .forEach(System.out::println);

Output

5
10
15
20
25

You can also collect a formatted string.

String result = Arrays.stream(numbers)
                      .mapToObj(String::valueOf)
                      .collect(java.util.stream.Collectors.joining(", "));

System.out.println(result);

// Output:
// 5, 10, 15, 20, 25

Output

5, 10, 15, 20, 25

Method 5: Printing 2D Arrays with Arrays.deepToString()

Arrays.toString() doesn’t handle nested arrays well — it just prints their memory addresses.

For 2D (or deeper) arrays, use Arrays.deepToString() instead.

int[][] matrix = {{1, 2}, {3, 4}};

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

// Output:
// [[1, 2], [3, 4]]

Output

[[1, 2], [3, 4]]

Step-by-Step Walkthrough

Let’s dissect the canonical example line by line.

Class and main method

Every Java program requires a public class container and a public static void main(String[] args) entry point, since the JVM specifically looks for this method signature to begin execution.

Array declaration

int[] numbers = {5, 10, 15, 20, 25};

Creates and fills a 5-element array in a single statement.

The loop condition

i < numbers.length

is the safeguard that prevents ArrayIndexOutOfBoundsException.

It always evaluates against the current length of the array, which for a fixed-size array never changes after creation.

The print statement

System.out.println(numbers[i]);

retrieves the value stored at index i and writes it, followed by a newline, to standard output.

Internal Working (Memory View)

Stack

Stack
├── numbers → reference to heap array
└── i       → loop counter

Heap

Heap
[5][10][15][20][25]

Each call to numbers[i] dereferences the numbers variable (stored on the stack) to locate the array object on the heap, then reads the value at the computed offset.

This is why array access is O(1) — the JVM can calculate the memory address of any index directly using the base address plus (index × element size).

Real-Life Analogy

Imagine a row of numbered boxes on a shelf.

Printing the array is like walking past each box in order, opening it, and reading aloud what’s inside — simple, sequential, and predictable.

Best Practices

• Use Arrays.toString() for quick, readable debug output rather than manual loops when you just need to inspect values.
• Prefer the enhanced for loop for read-only iteration; reserve the indexed loop for cases where you specifically need the index.
• For 2D or nested arrays, always use Arrays.deepToString() — never Arrays.toString().
• When logging in production systems, consider a proper logging framework (e.g., SLF4J) rather than System.out.println().

Common Mistakes

Calling System.out.println(array) Directly

This prints a hash-based reference string, not the values.

Using Arrays.toString() on a 2D Array

It produces nested memory addresses instead of visible values.

Use:

Arrays.deepToString(array);

instead.

Off-by-One Errors

Using:

i <= numbers.length

instead of:

i < numbers.length

causes an ArrayIndexOutOfBoundsException.

Forgetting the Import

Always import:

import java.util.Arrays;

before using Arrays.toString() or Arrays.deepToString().

Expert Tips

• Arrays.toString() works for arrays of objects too, as long as the object’s class overrides toString() meaningfully.
• Streams shine when you need to combine printing with transformation, such as printing only even numbers or formatted currency values.
• For extremely large arrays, avoid printing the whole array in production logs — consider summarizing (count, min, max) instead.

Comparison of All Methods

Arrays.stream(objectArray)
     .forEach(System.out::println);

arr.length - 1

0