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

【问题标题】：What's the simplest way to print a Java array?打印 Java 数组的最简单方法是什么？
【发布时间】：2021-11-11 05:27:34
【问题描述】：

在Java中，数组不会覆盖toString()，所以如果你尝试直接打印一个，你会得到className + '@' + 数组的十六进制hashCode，由@定义987654328@:

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

但通常情况下，我们实际上想要更像[1, 2, 3, 4, 5] 的东西。最简单的方法是什么？以下是一些示例输入和输出：

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

【问题讨论】：

您希望字符串以外的对象的表示形式是什么？调用toString的结果？是否加引号？
是的对象将由它们的 toString() 方法表示，不带引号（刚刚编辑了示例输出）。
在实践中，与stackoverflow.com/questions/29140402/…密切相关
那个奇怪的输出不一定是内存位置。这是十六进制的hashCode()。见Object#toString()。
在java8中打印单维或多维数组检查stackoverflow.com/questions/409784/…

标签： java arrays printing

【解决方案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 ]

【讨论】：

如果我们有一个字符串数组，并且想要简单的输出；比如：String[] array = {"John", "Mahta", "Sara"}，我们希望这个输出没有括号和逗号：John Mahta Sara?
@Hengameh：还有其他几种方法可以做到这一点，但我最喜欢的是这个：javahotchocolate.com/notes/java.html#arrays-tostring。
仅供参考，Arrays.deepToString() 仅接受 Object []（或扩展 Object 的类数组，例如 Integer，因此它不适用于 @ 类型的原始数组987654344@。但Arrays.toString(<int array>) 适用于原始数组。
@Hengameh 有专门的方法。 System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"})) 将打印 John Mahta Sara。
别忘了“import java.util.Arrays;”

【解决方案2】：

始终首先检查标准库。

import java.util.Arrays;

那就试试吧：

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

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

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

【讨论】：

@Hengameh 现在使用 Java 8：String.join(" ", Arrays.asList(array))。 doc

【解决方案3】：

很高兴知道，但是，至于“总是先检查标准库”，我永远不会偶然发现 Arrays.toString( myarray ) 的把戏

--因为我专注于 myarray 的类型以了解如何执行此操作。我不想遍历这件事：我想要一个简单的调用，让它类似于我在 Eclipse 调试器中看到的那样，而 myarray.toString() 只是没有这样做。

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

【讨论】：

【解决方案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
*/

【讨论】：

【解决方案5】：

从 Java 8 开始，还可以利用 String class 提供的 join() 方法打印出不带括号的数组元素，并由选择的分隔符分隔（这是用于示例如下）：

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

输出将是“嘿，朋友！”。

【讨论】：

【解决方案6】：

Arrays.toString

作为直接答案，the solution provided by several, including @Esko 使用 Arrays.toString 和 Arrays.deepToString 方法简直是最好的。

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

下面我尝试列出一些其他建议的方法，尝试改进一点，其中最值得注意的添加是使用Stream.collect 运算符，使用joining Collector，以模仿@ 987654331@正在做。

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

【讨论】：

【解决方案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]]
[[约翰，布拉沃]，[玛丽，李]，[鲍勃，约翰逊]]
11
12
21
22
31
32
33
约翰
棒棒哒
玛丽
李
鲍勃
约翰逊

【讨论】：

【解决方案8】：

如果您使用的是 Java 1.4，则可以改为：

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

（当然，这也适用于 1.5+。）

【讨论】：

不幸的是，这只适用于对象数组，不适用于基元数组。

【解决方案9】：

Arrays.deepToString(arr) 只打印一行。

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

要真正将表格打印为二维表格，我必须这样做：

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

似乎Arrays.deepToString(arr) 方法应该采用分隔符字符串，但不幸的是它没有。

【讨论】：

也许使用 System.getProperty("line.separator");而不是 \r\n 所以它也适用于非 Windows。

【解决方案10】：

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

【讨论】：

这样你最终会得到一个空白空间；）
@matthiad .. 这一行将避免出现空白 System.out.println(n+ (someArray.length == n) ? "" : " ");
@MuhammadSuleman 这不起作用，因为这是一个 for-each 循环。 n 是数组中的实际值，而不是索引。对于常规的 for 循环，它也是 (someArray.length - 1) == i，因为它会在 i 等于数组长度时中断。

【解决方案11】：

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

简单的方法

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

输出： [一二三四]

使用 toString()

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

输出：[一、二、三、四]

打印数组的数组

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] [[第五，第六]，[第七，第八]]

资源：Access An Array

【讨论】：

【解决方案12】：

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

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

它提供与您一样的输出 1、2、3、4、5

【讨论】：

它打印“1, 2, 3, 4, 5, ”作为输出，它也在最后一个元素之后打印逗号。
您可以将循环中的代码替换为System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
您也可以使用System.out.print(i + (i < intArray.length - 1 ? ", " : "")); 合并这两行。

【解决方案13】：

无论您使用哪个 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};

更新：

是的！值得一提的是，将数组转换为对象数组或使用对象数组的成本很高，并且可能会减慢执行速度。它是由称为自动装箱的java的性质发生的。

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

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

【讨论】：

为了打印目的而将数组转换为列表似乎不是一个非常机智的决定。并且鉴于同一个班级有一个toString(..)，这让我无法理解为什么有人会这样做。

【解决方案14】：

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

请注意，这绝不是永久修复。只是一个可以使调试更简单的 hack。

打印一个数组直接给出内部表示和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(..)，以添加对包含其他数组的数组的支持。

我发现这是一个非常有用的 hack，如果 Java 可以简单地添加它，那就太好了。我理解拥有非常大的数组的潜在问题，因为字符串表示可能有问题。可能会通过System.out或PrintWriter之类的东西来应对这种情况。

【讨论】：

【解决方案15】：

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

流：Arrays.stream(intArray).forEach

方法参考：::println

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

如果你想在同一行打印数组中的所有元素，那么只需使用print 而不是println 即

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

【讨论】：

【解决方案16】：

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

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

【讨论】：

【解决方案17】：

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

【讨论】：

【解决方案18】：

如果您的数组是 char[] 类型，还有另一种方法：

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

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

打印

abc

【讨论】：

【解决方案19】：

我尝试过的简化快捷方式是这样的：

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

它会打印出来

1
2
3

这种方法不需要循环，最好只用于小数组

【讨论】：

【解决方案20】：

可以选择使用 org.apache.commons.lang3.StringUtils.join(*) 方法
例如：

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

我使用了以下依赖项

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

【讨论】：

由于在两行代码中完成的琐碎事情而添加依赖项是一种尖叫的反模式。
commons-lang3 是一个非常流行的依赖项，请注意，这个答案是大多数人没有使用 java 8
仍然是stackoverflow.com/questions/38425623/…commons-lang 中提到的最佳解决方案当然非常流行，应该使用而不是自己实现。此类实用方法必须经过测试，并且还应该可用于其他项目。只要原始数组不能简单处理，像 common-lang 这样带有重载方法的库对我来说是解决这个问题的最好和有效的方法。

【解决方案21】：

for-each 循环也可用于打印数组元素：

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

【讨论】：

@firephil System.out.println(a[i]);与普通 for 循环一起使用，其中创建索引“i”并打印每个索引处的值。我使用了“for each”循环。试试看，希望你能明白我的意思。

【解决方案22】：

要添加到所有答案，也可以选择将对象打印为 JSON 字符串。

使用杰克逊：

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

使用 Gson：

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

【讨论】：

这就是我所做的。有了这个，您可以打印任意复杂的结构，只要它们可编码为 JSON。我总是确保使用“漂亮”。你的第二个例子是这样做的吗？我认为您需要勾选一个“漂亮”选项才能获得它。

【解决方案23】：

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

【讨论】：

【解决方案24】：

这里有一个可能的打印功能：

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

比如如果main是这样的

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

输出将是 { [1] [2] [3] [4] }

【讨论】：

【解决方案25】：

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

【讨论】：

【解决方案26】：

这被标记为printing a byte[] 的重复项。注意：对于字节数组，还有其他可能适用的方法。

如果它包含 ISO-8859-1 字符，您可以将其打印为字符串。

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

或者如果它包含一个 UTF-8 字符串

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

或者如果您想将其打印为十六进制。

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

或者如果您想将其打印为 base64。

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

或者如果你想打印一个有符号字节值的数组

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

或者如果你想打印一个无符号字节值数组

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.

【讨论】：

【解决方案27】：

如果你运行的是 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);

输出：

[7,3,5,1,3]

【讨论】：

这比公认的答案更好，因为它可以更好地控制分隔符、前缀和后缀。但是，我会在最后的System.out.println() 中删除多余的toString() 并在joiner.add(element.toString()) 中使用它，而不是添加空字符串。此解决方案同样适用于非原始类型的数组。
我的错，element.toString() 内 joiner.add() 仅适用于非原始类型。您仍然需要使用Integer.toString(element) - 类似于原始类型的构造。就个人而言，我使用 foreach 循环 for (int element : array) joiner.add(Integer.toString(element)); 而不是流，但这是品味问题。

【解决方案28】：

如果您使用的是 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("]", ""));
     }
}

输出：

John Mahta Sara

【讨论】：

【解决方案29】：

在 Java 8 中：

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

【讨论】：

那些创建投票以删除我的答案的人..您可以公开您的观点以便每个人都可以学习吗？这个问题要求在java中最简单的方法，所以它是一个单行，java当前版本是> 14，我的解决方案至少适用于java 8（所以它适用）。

【解决方案30】：

如果使用Commons.Lang library，我们可以这样做：

ArrayUtils.toString(array)

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

输出：

{1,2,3,4,5}
{John,Mary,Bob}

【讨论】：

简单数组：

嵌套数组：

double数组：

int数组：

Arrays.toString

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

Java 8 之前

Java 8

`double`数组：

`int`数组：