打印Java数组最简单的方法是什么？

Question

在Java中,数组不会覆盖toString(),因此如果您尝试直接打印数组,则会获得className + @ + className数组的十六进制,如下所示hashCode:

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

但通常我们实际上想要更像的东西Object.toString().这样做最简单的方法是什么？以下是一些示例输入和输出:

// 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

从Java 5开始,您可以在数组中使用Arrays.toString(arr)或使用Arrays.deepToString(arr)数组.请注意,该Object[]版本调用.toString()数组中的每个对象.输出甚至以您要求的方式进行装饰.

例子:

• 简单数组:

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

  输出:

  [John, Mary, Bob]
  

• 嵌套数组:

  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));
  

  输出:

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

• double 阵:

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

  输出:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]
  

• int 阵:

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

  输出:

  [7, 9, 5, 1, 3 ]
  

Answer 2

始终首先检查标准库.尝试:

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

或者如果您的数组包含其他数组作为元素:

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

Answer 3

然而,很高兴知道,"总是首先检查标准库",我从来没有偶然发现过 Arrays.toString( myarray )

- 因为我专注于myarray的类型,看看如何做到这一点.我不想迭代这件事:我想要一个简单的调用来使它类似于我在Eclipse调试器中看到的而myarray.toString()就是没有这样做.

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

Answer 4

在JDK1.8中,您可以使用聚合操作和lambda表达式:

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

如果您使用的是Java 1.4,则可以执行以下操作:

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

(当然,这也适用于1.5+.)

Answer 6

从Java 8开始,人们还可以利用String类join()提供的方法打印出数组元素,不带括号,并用选择的分隔符(下面显示的示例的空格字符)分隔:

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

输出将是"嘿有amigo!".

Answer 7

在Java 8之前

我们可以用来Arrays.toString(array)打印一维数组和Arrays.deepToString(array)多维数组.

Java 8

现在我们可以选择Stream和lambda打印数组.

打印一维数组:

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);
}

输出是:

[1,2,3,4,5]
[约翰,玛丽,鲍勃]
1
2
3
4
5
约翰
玛丽
鲍勃

打印多维数组 如果我们想要打印多维数组,我们可以使用Arrays.deepToString(array):

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);
} 

现在要注意的是该方法Arrays.stream(T[]),在int[]返回我们Stream<int[]>然后方法的情况下,flatMapToInt()通过将提供的映射函数应用于每个元素而生成的映射流的内容映射流的每个元素.

输出是:

[[11,12],[21,22],[31,32,33]]
[[John,Bravo],[Mary,Lee],[Bob,Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
李
鲍勃·
约翰逊

Answer 8

Arrays.toString

作为一个直接的答案,几个人提供的解决方案,包括@Esko,使用Arrays.toString和Arrays.deepToString方法,是最好的.

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

下面我尝试列出一些建议的其他方法,尝试改进一点,最显着的增加是使用Stream.collect运算符,使用a 来模仿正在做的事情.joining CollectorString.join

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 9

Arrays.deepToString(arr) 仅打印在一行上.

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

要实际将表打印为二维表,我必须这样做:

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

看起来这个Arrays.deepToString(arr)方法应该采用分隔符字符串,但不幸的是它没有.

Answer 10

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

Answer 11

在Java中打印数组的不同方法:

1. 简单的方法

   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);
   

输出:[一,二,三,四]

2. 运用 toString()

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

输出:[一,二,三,四]

3. 打印阵列数组

   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));
   

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

资源:访问数组

Answer 12

在我看来,使用常规for循环是打印数组的最简单方法.这里有一个基于intArray的示例代码

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

它提供的输出为你的1,2,3,4,5

Answer 13

我最近在Vanilla #Java中看过这篇文章.写作不是很方便Arrays.toString(arr);,然后一直导入java.util.Arrays;.

请注意,这绝不是永久性修复.只是一个可以使调试更简单的黑客攻击.

直接打印数组会给出内部表示和hashCode.现在,所有类都具有Object父类型.那么,为什么不破解Object.toString()？没有修改,Object类看起来像这样:

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

如果将其更改为:

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());
}

通过在命令行中添加以下内容,可以简单地将此修改类添加到类路径中:-Xbootclasspath/p:target/classes.

现在,随着deepToString(..)Java 5的推出,toString(..)可以轻松地将其更改deepToString(..)为添加对包含其他数组的阵列的支持.

我发现这是一个非常有用的黑客,如果Java可以简单地添加它,那将是很好的.我理解拥有非常大的数组的潜在问题,因为字符串表示可能有问题.也许会传递像a System.out或a PrintWriter这样的可能性.

Answer 14

它应该始终适用于您使用的JDK版本:

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

如果Array包含对象,它将起作用.如果Array包含基本类型,则可以使用包装类而不是直接将基元存储为..

例:

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

替换为:

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

更新:

是的!这是值得一提的是,将数组转换为对象数组或使用Object的数组是昂贵的,并且可能会降低执行速度.它发生在称为autoboxing的java的本质上.

因此,仅用于打印目的,不应使用它.我们可以创建一个以数组作为参数并打印所需格式的函数

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

Answer 15

在java 8中很容易.有两个关键字

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

2. 方法参考: ::println

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

如果要在同一行中打印数组中的所有元素,则只需使用print而不是printlnie

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

没有方法参考的另一种方法就是使用

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

Answer 16

• 在JAVA中，无需使用任何循环即可打印数组，这是一种非常简单的方法。

  -> 对于单个或简单数组：

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

  输出 ：

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

  -> 所以，这个二维数组不能用 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));
  

  输出：

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

Answer 17

如果您的数组类型为char [],还有一种方法:

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

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

版画

abc

Answer 18

要添加到所有答案,将对象打印为JSON字符串也是一种选择.

使用杰克逊:

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

使用Gson:

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

Answer 19

您可以遍历数组，并在循环时打印出每个项目。例如：

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

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

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

}

输出：

item 1
item 2
item 3

Answer 20

有以下方式打印数组

 // 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);
     }