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

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

例子：

简单数组：String[] array = new String[] {"John", "Mary", "Bob"}; System.out.println(Arrays.toString(array));输出：[约翰，玛丽，鲍勃]

嵌套数组：String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}}; System.out.println(Arrays.toString(deepArray)); //输出：[[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922] System.out.println(Arrays.deepToString(deepArray));输出：[[约翰，玛丽]，[爱丽丝，鲍勃]]

双数组：双[] 双数组 = { 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]

---

始终首先检查标准库。

import java.util.Arrays;

然后尝试：

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

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

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

---

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

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

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

---

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

---

数组.toString

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

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

下面我尝试列出一些其他建议的方法，并尝试进行一些改进，其中最值得注意的添加是使用 Stream.collect 运算符，使用 joining Collector 来模仿 String.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);

---

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

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

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

---

在 Java 8 之前

我们可以使用 Arrays.toString(array) 打印一维数组，使用 Arrays.deepToString(array) 打印多维数组。

爪哇 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李·鲍勃·约翰逊

---

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

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

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

---

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

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

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

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

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

---

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

---

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

简单方式 List list = new ArrayList(); list.add("一个"); list.add("两个"); list.add("三"); list.add("四"); // 在控制台打印列表 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

---

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

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

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

---

它应该始终适用于您使用的任何 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
} 

---

我最近在 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。

现在，随着自 Java 5 以来 deepToString(..) 的可用性，可以轻松地将 toString(..) 更改为 deepToString(..) 以添加对包含其他数组的数组的支持。

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

---

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

---

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

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

---

有以下打印数组的方法

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

---

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

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

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

印刷

abc

---

我试过的一个简化的捷径是这样的：

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

它会打印

1
2
3

这种方法不需要循环，最好只用于小型阵列

---

使用 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>

---

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

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

---

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

☻♥完成保留代码

---

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

使用杰克逊：

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

使用 Gson：

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

---

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

---

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

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

---

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

---

这被标记为 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.

---

如果您正在运行 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]

---

如果您使用的是 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

---

在 Java 8 中：

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

---