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

Question

In Java, arrays don't override toString() , so if you try to print one directly, you get the className + '@' + the hex of the hashCode of the array, as defined by Object.toString() :

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray); // Prints something like '[I@3343c8b3'

But usually, we'd actually want something more like [1, 2, 3, 4, 5] . What's the simplest way of doing that? Here are some example inputs and outputs:

// Array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};
// Output: [1, 2, 3, 4, 5]

// Array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};
// Output: [John, Mary, Bob]

Answer 1

Since Java 5 you can use Arrays.toString(arr) or Arrays.deepToString(arr) for arrays within arrays. Note that the Object[] version calls .toString() on each object in the array. The output is even decorated in the exact way you're asking.

Examples:

• Simple Array:

   String[] array = new String[] {"John", "Mary", "Bob"}; System.out.println(Arrays.toString(array));

  Output:

   [John, Mary, Bob]

• Nested Array:

   String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}}; System.out.println(Arrays.toString(deepArray)); //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922] System.out.println(Arrays.deepToString(deepArray));

  Output:

   [[John, Mary], [Alice, Bob]]

• double Array:

   double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 }; System.out.println(Arrays.toString(doubleArray));

  Output:

   [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Array:

   int[] intArray = { 7, 9, 5, 1, 3 }; System.out.println(Arrays.toString(intArray));

  Output:

   [7, 9, 5, 1, 3 ]

Answer 2

Always check the standard libraries first.

import java.util.Arrays;

Then try:

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

or if your array contains other arrays as elements:

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

Answer 3

This is nice to know, however, as for "always check the standard libraries first" I'd never have stumbled upon the trick of Arrays.toString( myarray )

--since I was concentrating on the type of myarray to see how to do this. I didn't want to have to iterate through the thing: I wanted an easy call to make it come out similar to what I see in the Eclipse debugger and myarray.toString() just wasn't doing it.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

Answer 4

In JDK1.8 you can use aggregate operations and a lambda expression:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

Answer 5

Arrays.toString

As a direct answer, the solution provided by several, including @Esko , using the Arrays.toString and Arrays.deepToString methods, is simply the best.

Java 8 - Stream.collect(joining()), Stream.forEach

Below I try to list some of the other methods suggested, attempting to improve a little, with the most notable addition being the use of the Stream.collect operator, using a joining Collector , to mimic what the String.join is doing.

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

Answer 6

Starting with Java 8, one could also take advantage of the join() method provided by the String class to print out array elements, without the brackets, and separated by a delimiter of choice (which is the space character for the example shown below):

String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting) 

The output will be "Hey there amigo!".

Answer 7

Prior to Java 8

We could have used Arrays.toString(array) to print one dimensional array and Arrays.deepToString(array) for multi-dimensional arrays.

Java 8

Now we have got the option of Stream and lambda to print the array.

Printing One dimensional Array:

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

The output is:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

Printing Multi-dimensional Array Just in case we want to print multi-dimensional array we can use Arrays.deepToString(array) as:

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

Now the point to observe is that the method Arrays.stream(T[]) , which in case of int[] returns us Stream<int[]> and then method flatMapToInt() maps each element of stream with the contents of a mapped stream produced by applying the provided mapping function to each element.

The output is:

[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
Lee
Bob
Johnson

Answer 8

If you're using Java 1.4, you can instead do:

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

(This works in 1.5+ too, of course.)

Answer 9

Arrays.deepToString(arr) only prints on one line.

int[][] table = new int[2][2];

To actually get a table to print as a two dimensional table, I had to do this:

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

It seems like the Arrays.deepToString(arr) method should take a separator string, but unfortunately it doesn't.

Answer 10

for(int n: someArray) {
    System.out.println(n+" ");
}

Answer 11

Different Ways to Print Arrays in Java:

1. Simple Way

   List<String> list = new ArrayList<String>(); list.add("One"); list.add("Two"); list.add("Three"); list.add("Four"); // Print the list in console System.out.println(list);

Output: [One, Two, Three, Four]

2. Using toString()

    String[] array = new String[] { "One", "Two", "Three", "Four" }; System.out.println(Arrays.toString(array));

Output: [One, Two, Three, Four]

3. Printing Array of Arrays

   String[] arr1 = new String[] { "Fifth", "Sixth" }; String[] arr2 = new String[] { "Seventh", "Eight" }; String[][] arrayOfArray = new String[][] { arr1, arr2 }; System.out.println(arrayOfArray); System.out.println(Arrays.toString(arrayOfArray)); System.out.println(Arrays.deepToString(arrayOfArray));

Output: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[Fifth, Sixth], [Seventh, Eighth]]

Resource: Access An Array

Answer 12

Using regular for loop is the simplest way of printing array in my opinion. Here you have a sample code based on your intArray

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

It gives output as yours 1, 2, 3, 4, 5

Answer 13

It should always work whichever JDK version you use:

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

It will work if the Array contains Objects. If the Array contains primitive types, you can use wrapper classes instead storing the primitive directly as..

Example:

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

Replace it with:

Integer[] a = new Integer[]{1,2,3,4,5};

Update :

Yes ! this is to be mention that converting an array to an object array OR to use the Object's array is costly and may slow the execution. it happens by the nature of java called autoboxing.

So only for printing purpose, It should not be used. we can make a function which takes an array as parameter and prints the desired format as

public void printArray(int [] a){
        //write printing code
} 

Answer 14

I came across this post in Vanilla #Java recently. It's not very convenient writing Arrays.toString(arr);, then importing java.util.Arrays; all the time.

Please note, this is not a permanent fix by any means. Just a hack that can make debugging simpler.

Printing an array directly gives the internal representation and the hashCode. Now, all classes have Object as the parent-type. So, why not hack the Object.toString() ? Without modification, the Object class looks like this:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

What if this is changed to:

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

This modded class may simply be added to the class path by adding the following to the command line: -Xbootclasspath/p:target/classes .

Now, with the availability of deepToString(..) since Java 5, the toString(..) can easily be changed to deepToString(..) to add support for arrays that contain other arrays.

I found this to be a quite useful hack and it would be great if Java could simply add this. I understand potential issues with having very large arrays since the string representations could be problematic. Maybe pass something like a System.out or a PrintWriter for such eventualities.

Answer 15

In java 8 it is easy. there are two keywords

1. stream: Arrays.stream(intArray).forEach

2. method reference: ::println

    int[] intArray = new int[] {1, 2, 3, 4, 5}; Arrays.stream(intArray).forEach(System.out::println);

If you want to print all elements in the array in the same line, then just use print instead of println ie

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

Another way without method reference just use:

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));

Answer 16

You could loop through the array, printing out each item, as you loop. For example:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

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

}

Output:

item 1
item 2
item 3

Answer 17

There Are Following way to print Array

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }

Answer 18

There's one additional way if your array is of type char[]:

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

prints

abc

Answer 19

A simplified shortcut I've tried is this:

    int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

It will print

1
2
3

No loops required in this approach and it is best for small arrays only

Answer 20

Using org.apache.commons.lang3.StringUtils.join(*) methods can be an option
For example:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

I used the following dependency

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

Answer 21

For-each loop can also be used to print elements of array:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);

Answer 22

• It is very simple way to print array without using any loop in JAVA.

  -> For, Single or simple array:

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

  The Output :

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

  -> So, this 2D array can't be printed with Arrays.toString()

   int[][] array = new int[][]{{1, 2, 3, 4, 5, 6, 7}, {8, 9, 10, 11, 12,13,14}}; System.out.println(Arrays.deepToString(array));

  The Output:

   [[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]

☻♥ Done Keep Code

Answer 23

To add to all the answers, printing the object as a JSON string is also an option.

Using Jackson:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Using Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));

Answer 24

// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

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

output: [1, 2, 3, 4, 5]

---

// array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};

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

output: [John, Mary, Bob]

Answer 25

Here a possible printing function:

  public static void printArray (int [] array){
        System.out.print("{ ");
        for (int i = 0; i < array.length; i++){
            System.out.print("[" + array[i] + "] ");
        }
        System.out.print("}");
    }

For example, if main is like this

public static void main (String [] args){
    int [] array = {1, 2, 3, 4};
    printArray(array);
}

the output will be { [1] [2] [3] [4] }

Answer 26

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

Answer 27

This is marked as a duplicate for printing a byte[] . Note: for a byte array there are additional methods which may be appropriate.

You can print it as a String if it contains ISO-8859-1 chars.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

or if it contains a UTF-8 string

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

or if you want print it as hexadecimal.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

or if you want print it as base64.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

or if you want to print an array of signed byte values

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

or if you want to print an array of unsigned byte values

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.

Answer 28

if you are running jdk 8.

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}


int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

output:

[7,3,5,1,3]

Answer 29

If you are using Java 11

import java.util.Arrays;
public class HelloWorld{

     public static void main(String []args){
        String[] array = { "John", "Mahta", "Sara" };
       System.out.println(Arrays.toString(array).replace(",", "").replace("[", "").replace("]", ""));
     }
}

Output :

John Mahta Sara

Answer 30

在 Java 8 中：

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

Answer 31

If using Commons.Lang library<\/a> , we could do:

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

Answer 32

In JDK1.8 you can use aggregate operations and a lambda expression:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

 // #3
 Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

Answer 33

There are several ways to print an array elements.First of all, I'll explain that, what is an array?..Array is a simple data structure for storing data..When you define an array , Allocate set of ancillary memory blocks in RAM.Those memory blocks are taken one unit ..

Ok, I'll create an array like this,

class demo{
      public static void main(String a[]){

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

           System.out.print(number);
      }
}

Now look at the output,

You can see an unknown string printed..As I mentioned before, the memory address whose array(number array) declared is printed.If you want to display elements in the array, you can use "for loop " , like this..

class demo{
      public static void main(String a[]){

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

           int i;

           for(i=0;i<number.length;i++){
                 System.out.print(number[i]+"  ");
           }
      }
}

Now look at the output,

Ok,Successfully printed elements of one dimension array..Now I am going to consider two dimension array..I'll declare two dimension array as "number2" and print the elements using "Arrays.deepToString()" keyword.Before using that You will have to import 'java.util.Arrays' library.

 import java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};`

           System.out.print(Arrays.deepToString(number2));
      }
}

consider the output,

At the same time , Using two for loops ,2D elements can be printed..Thank you !

Answer 34

toString is a way to convert an array to string.

Also, you can use:

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

This for loop will enable you to print each value of your array in order.

Answer 35

By using the java.util.Arrays:

String mRole = "M_XXX_ABC";        
System.out.println(Arrays.asList(mRole.split("_")).toString());

output: [M, XXX, ABC]

Answer 36

Java array is a data structure where we can store the elements of the same data type. The elements of an array are stored in a contiguous memory location. So, we can store a fixed set of elements in an array.

In Java, arrays are objects. All methods of class object may be invoked in an array. We can store a fixed number of elements in an array.

Example :

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);

output:

[I@63961c42

Why did Java not print our array? What is happening under the hood?

The System.out.println() method converts the object we passed into a string by calling String.valueOf() . If we look at the String.valueOf() method's implementation, we'll see this:

public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}

If the passed-in object is null it returns null, else it calls obj.toString() . Eventually, System.out.println() calls toString() to print the output.

If that object's class does not override Object.toString()'s implementation, it will call the Object.toString() method.

Object.toString() returns getClass().getName()+'@'+Integer.toHexString(hashCode()) . In simple terms, it returns: “class name @ object's hash code”.

In our previous output [I@63961c42 , the [ states that this is an array, and I stands for int (the type of the array). 63961c42 is the unsigned hexadecimal representation of the hash code of the array.

Whenever we are creating our own custom classes, it is a best practice to override the Object.toString() method.

There are following ways to print an array in Java

---

for loop

Java for loop is used to execute a set of statements repeatedly until a particular condition is satisfied.

In the following example, we have created an array of length three and initialized elements into it. We have used for loop for fetching the values from the array. It is the most popular way to print array in Java.

    String[] strArray = new String[]{"John", "Mary", "Bob"};
    for (int i = 0; i < strArray.length; i++)    
        System.out.println(strArray[i]);

output:

 John
 Mary
 Bob

for each

Java for-each loop is also used to traverse over an array or collection. It works on the basis of elements. It returns elements one by one in the defined variable.

String[] strArray = new String[]{"John", "Mary", "Bob"};
    for (String str : strArray)
        System.out.println(str);

output:

John
Mary
Bob

Arrays.toString()

String[] strArray = new String[]{"John", "Mary", "Bob"};
        System.out.println(Arrays.toString(strArray));

output:

[John, Mary, Bob]

According to your question above output is exact what you want

Arrays.deepToString() {Off Topic}

The deepToString() method of Java Arrays class is designed for converting multidimensional arrays to strings.

It accepts an array as a parameter. It returns the String representation of an array.

In the following example, we have created a two dimensional array of Integer type.

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

output:

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

Arrays.asList()

Java Arrays.asList() is a static method of Java Arrays class which belongs to java.util package. It act as a bridge between array based and collection based API.The method also provides an easy way to create a fixed-size list initialize to contain many elements.It accepts an array as an argument. It returns the list view of an array.

String[] strArray = new String[]{"John", "Mary", "Bob"};
        System.out.println(Arrays.asList(strArray));

output:

[John, Mary, Bob]

Iterator interface

Iterator is an interface which belongs to java.util package. The Iterator object can be created by calling iterator() method. It is present in Collection interface. It returns an iterator.

 String[] strArray = new String[]{"John", "Mary", "Bob"};
    Iterator<String> it = Arrays.asList(strArray).iterator();
    while (it.hasNext())
        System.out.println(it.next());

output:

John
Mary
Bob

Stream API

The Stream API is used to process collections of objects. A stream is a sequence of objects. Streams don't change the original data structure, they only provide the result as per the requested operations.

There are two terminal operations which we can apply to a stream to print an array.

Get an iterator to the stream

Iterator it=Arrays.stream(strArray).iterator();  

Using stream().forEach()

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

Answer 37

Use the Arrays class. It has multiple utility methods and its toString() is overriden to display array elements in a human readable way. Arrays.toString(arr)

Answer 38

If you want to print, evaluate Array content like that you can use Arrays.toString

jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }

jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"

jshell>