Table of contents
1.
Introduction
2.
Java for loop
3.
Java for-each loop
4.
Java Arrays.toString() method
5.
Java Arrays.deepToString() method
6.
Java Arrays.asList() method
7.
Java Iterator Interface
8.
Java Stream API
9.
Frequently Asked Questions
9.1.
Can I modify the elements of an array while using the for-each loop?
9.2.
Is it possible to print a multidimensional array using Arrays.toString()?
9.3.
Can I use the Stream API with arrays of primitive types?
10.
Conclusion
Last Updated: Aug 24, 2024
Easy

How to Print Array in Java

Author Riya Singh
0 upvote
Career growth poll
Do you think IIT Guwahati certified course can help you in your career?

Introduction

Arrays are a fundamental data structure in Java that allow you to store multiple values of the same data type in a single variable. Printing arrays is a common task that every Java programmer should know how to do. 

How to print array in Java

In this article, we will discuss different ways to print arrays in Java, like with the help of loops, built-in methods, and the Stream API. 

Java for loop

The most basic way to print an array in Java is by using a for loop. The for loop allows you to iterate through each element of the array and print them one by one. 

For example:

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.print(numbers[i] + " ");
}


Output

1 2 3 4 5


In this example, we declare an integer array called `numbers` with five elements. We then use a for loop to iterate through each element of the array. The loop starts from index 0 and continues until it reaches the last index of the array (`numbers.length - 1`). Inside the loop, we print each element of the array using `System.out.print()` and add a space after each element to separate them.

Note: The for loop is a simple way to print arrays in Java. It gives you complete control over the formatting of the output and allows you to perform additional operations on each element if needed.

Java for-each loop

Java provides an enhanced version of the for loop, known as the for-each loop or enhanced for loop, which simplifies the process of iterating through arrays. The for-each loop automatically iterates through each element of the array without the need for an explicit index variable. 

For example:

String[] fruits = {"apple", "banana", "orange", "grape"};
for (String fruit : fruits) {
    System.out.print(fruit + " ");
}


Output

apple banana orange grape


In this example, we have an array of strings called `fruits` that contains four elements. We use the for-each loop to iterate through each element of the array. The loop variable `fruit` takes on the value of each element in the array, one at a time. Inside the loop, we print each fruit using `System.out.print()` and add a space after each element.

The for-each loop provides a more concise and readable way to iterate through arrays compared to the traditional for loop. It eliminates the need to keep track of the index and reduces the chances of making errors related to array indexing.

However, it's important to note that the for-each loop does not provide access to the index of each element. If you need to work with the index or modify the array elements, you should use the traditional for loop instead.

Java Arrays.toString() method

Java provides a convenient built-in method called `Arrays.toString()` that allows you to print the contents of an array as a string representation. This method is part of the `java.util.Arrays` class and is commonly used for debugging and displaying array elements. 

For example:

import java.util.Arrays;

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

String arrayString = Arrays.toString(numbers);
System.out.println(arrayString);


Output

[1, 2, 3, 4, 5]


In this example, we have an integer array called `numbers` with five elements. We use the `Arrays.toString()` method to convert the array into a string representation. The method returns a string that contains the elements of the array enclosed in square brackets and separated by commas.

We store the resulting string in a variable called `arrayString` and then print it using `System.out.println()`. The output shows the elements of the array in a readable format.

The `Arrays.toString()` method is particularly useful when you want to quickly print the contents of an array for debugging purposes or when you need to display the array elements in a specific format.

Note: However, it's important to note that `Arrays.toString()` only works for one-dimensional arrays. If you have a multidimensional array, you need to use a different method, which we will discuss in the next section.

Java Arrays.deepToString() method

When working with multidimensional arrays in Java, you can use the `Arrays.deepToString()` method to print the contents of the array as a string representation. This method is similar to `Arrays.toString()` but is designed to handle arrays with multiple dimensions. 

For example

import java.util.Arrays;
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
String matrixString = Arrays.deepToString(matrix);
System.out.println(matrixString);


Output

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]


In this example, we have a two-dimensional integer array called `matrix` that represents a 3x3 matrix. Each element of the outer array is itself an array, representing a row of the matrix.

We use the `Arrays.deepToString()` method to convert the multidimensional array into a string representation. The method recursively traverses the array and its nested arrays, converting each element to a string and enclosing them in square brackets.

We store the resulting string in a variable called `matrixString` and then print it using `System.out.println()`. The output shows the elements of the matrix in a readable format, with each row enclosed in square brackets and separated by commas.

The `Arrays.deepToString()` method is useful when you are dealing with multidimensional arrays, as it provides a convenient way to visualize the structure and contents of the array.

Note: It's important to remember that `Arrays.deepToString()` can handle arrays with any number of dimensions, which makes it a versatile method for printing complex array structures.

Java Arrays.asList() method

Another useful method for printing arrays in Java is `Arrays.asList()`. This method allows you to convert an array into a fixed-size list, which can be easily printed using the `toString()` method of the list. 

For example

import java.util.Arrays;
import java.util.List;
String[] fruits = {"apple", "banana", "orange", "grape"};
List<String> fruitList = Arrays.asList(fruits);
System.out.println(fruitList);


Output

[apple, banana, orange, grape]


In this example, we have a string array called `fruits` that contains four elements. We use the `Arrays.asList()` method to convert the array into a list. The method takes the array as an argument and returns a fixed-size list backed by the original array.

We store the resulting list in a variable called `fruitList`. Since the `toString()` method of the list is automatically called when we print the list using `System.out.println()`, the output shows the elements of the list in a readable format, enclosed in square brackets and separated by commas.

Using `Arrays.asList()` in combination with the `toString()` method provides a concise way to print the contents of an array as a list.

Always remember that the list returned by `Arrays.asList()` is a fixed-size list, which means that you cannot add or remove elements from it. If you need a mutable list, you can create a new `ArrayList` and pass the array to its constructor:

List<String> mutableFruitList = new ArrayList<>(Arrays.asList(fruits));


This creates a new `ArrayList` that contains the elements of the `fruits` array, allowing you to modify the list as needed.

Java Iterator Interface

Another way to print arrays in Java is by using the Iterator interface. The Iterator interface provides a way to traverse through the elements of a collection, including arrays. 

For example : 

import java.util.Arrays;
import java.util.Iterator;
String[] colors = {"red", "green", "blue", "yellow"};
Iterator<String> iterator = Arrays.asList(colors).iterator();

while (iterator.hasNext()) {
    String color = iterator.next();
    System.out.print(color + " ");
}


Output

red green blue yellow


In this example, we have a string array called `colors` that contains four elements. We first convert the array into a list using `Arrays.asList()`. Then, we obtain an iterator for the list using the `iterator()` method.

We use a while loop to iterate through the elements of the array using the iterator. The `hasNext()` method of the iterator returns `true` if there are more elements to be traversed. Inside the loop, we call the `next()` method to get the next element and store it in a variable called `color`. We print each color using `System.out.print()` and add a space after each element.

Using an iterator provides a more flexible way to traverse through arrays, especially when you need to perform additional operations while iterating. Iterators allow you to remove elements during iteration using the `remove()` method, which is not possible with the enhanced for loop.

Note: Just remember that using an iterator requires a bit more code compared to other methods like for loops or `Arrays.toString()`. Iterators are more commonly used with collections like `ArrayList` or `LinkedList`.

Java Stream API

Java 8 introduced the Stream API, which provides a functional and expressive way to process collections, including arrays. You can use the Stream API to print arrays in a more concise and readable manner. 

For example

import java.util.Arrays;
int[] numbers = {1, 2, 3, 4, 5};
Arrays.stream(numbers)
    .forEach(num -> System.out.print(num + " "));


Output

1 2 3 4 5


In this example, we have an integer array called `numbers` with five elements. We use the `Arrays.stream()` method to create a stream from the array. The `stream()` method takes the array as an argument and returns a stream of its elements.

We then use the `forEach()` method of the stream to iterate through each element of the array. The `forEach()` method takes a lambda expression as an argument, which specifies the action to be performed on each element. In this case, we print each number using `System.out.print()` and add a space after each element.

Using the Stream API provides a more functional and expressive way to process arrays. It allows you to perform various operations like filtering, mapping, and reducing on the array elements using a fluent and readable syntax.

For example : 

String[] names = {"Rahul", "Rinki", "Harsh", "Sanjana", "Sinki"};
Arrays.stream(names)
    .filter(name -> name.startsWith("S"))
    .map(String::toUpperCase)
    .forEach(System.out::println);


Output

SANJANA
SINKI


In this example, we have a string array called `names` with five elements. We create a stream from the array using `Arrays.stream()`. We then apply a filter operation using the `filter()` method to select only the names that start with the letter "S". Next, we use the `map()` method to convert each filtered name to uppercase. Finally, we print each uppercase name using `System.out.println()`.

The Stream API provides a powerful and expressive way to manipulate and print arrays in Java. It allows you to perform complex operations with minimal code and improved readability.

Frequently Asked Questions

Can I modify the elements of an array while using the for-each loop?

No, the for-each loop does not allow you to modify the elements of an array directly. It is only used for reading the elements.

Is it possible to print a multidimensional array using Arrays.toString()?

No, Arrays.toString() is designed for one-dimensional arrays. To print a multidimensional array, you should use Arrays.deepToString() instead.

Can I use the Stream API with arrays of primitive types?

Yes, the Stream API provides specific methods for primitive arrays, such as IntStream.of() for int arrays, LongStream.of() for long arrays, and DoubleStream.of() for double arrays.

Conclusion

In this article, we have learned various ways to print arrays in Java. We explained the traditional for loop, the enhanced for-each loop, and built-in methods like Arrays.toString() and Arrays.deepToString(). We also looked at converting arrays to lists with the help of Arrays.asList() and traversing arrays using the Iterator interface. Finally, we discussed the Stream API introduced in Java 8, which provides a functional and expressive way to process and print arrays.

You can also check out our other blogs on Code360.

Live masterclass