Question

在Java中，数组不会覆盖toString()，因此如果您尝试直接打印一个，则得到className + @ +数组的hashCode的十六进制，由{定义{1}}：

Object.toString()

但通常我们真的想要更像int[] intArray = new int[] {1, 2, 3, 4, 5}; System.out.println(intArray); // prints something like '[I@3343c8b3'的东西。这样做最简单的方法是什么？以下是一些示例输入和输出：

[1, 2, 3, 4, 5]

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 class提供的join()方法打印出数组元素，不带括号，并用选择的分隔符分隔（即下面显示的示例的空格字符）：

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

输出将是“Hey there amigo！”。

Answer 7

Arrays.toString

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

Java 8 - Stream.collect（join（）），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);

Answer 8

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个
  约翰
  布拉沃
  玛丽
  李
  鲍勃
  约翰逊

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中打印数组的不同方法：

简单方法

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    routes.MapRoute(
        name: "Default",
        url: "web/{controller}/{action}/{id}",
        defaults: new { controller = "Parking", action = "Get", id = UrlParameter.Optional }
    );
}

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

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

输出：[[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1， [Ljava.lang.String; @ 42719c] [[第五，第六]，[第七，第八]]

资源：Access An Array

Answer 12

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

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

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

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

更新：

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

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

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

Answer 14

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

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

Answer 15

我最近在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(..)，以添加对包含其他数组的数组的支持。

我发现这是一个非常有用的黑客，如果Java可以简单地添加它，那将会很棒。我理解拥有非常大的数组的潜在问题，因为字符串表示可能有问题。对于这种可能性，可能会传递类似System.out或PrintWriter的内容。

Answer 16

如果您的数组类型为char []：

，还有一种方法

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

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

打印

abc

Answer 17

要添加所有答案，将对象打印为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 18

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

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

会打印

1
2
3

此方法不需要循环，最好只适用于小型数组

Answer 19

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

myVariable

输出：

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

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

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

}

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

Answer 21

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

Answer 22

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 23

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

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

Answer 24

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

Answer 25

如果您使用的是 Java 11

{
"ErrorType": "USER_NOT_ALLOWED",
"Message": "Token is authorized to access only a video. Trace id: '6a0bd50f-d25e-405f-b853-86847c8a1bca"

输出：

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

Answer 26

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

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

另外，从Java 8开始，还可以利用String类提供的join（）方法来打印出数组元素，不带方括号，并用选择的定界符分隔（这是空格）下面显示的示例）

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

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

Answer 28

通过使用 java.util.Arrays：

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

输出：[M, XXX, ABC]

Answer 29

可能的打印功能：

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

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

Answer 31

如果您正在运行jdk8。

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]

Answer 32

有几种打印数组元素的方法。首先，我将解释什么是数组？.Array是用于存储数据的简单数据结构。当定义数组时，分配一组RAM中的辅助存储块。这些存储块被当作一个单元。

好吧，我将创建一个像这样的数组

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

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

           System.out.print(number);
      }
}

现在看看输出，

您可以看到打印了一个未知字符串。如前所述，已打印声明了array（number array）的内存地址。如果要显示数组中的元素，可以使用“ for loop”，例如..

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

现在看看输出，

好，成功打印一维数组的元素。现在，我将考虑二维数组。我将二维数组声明为“ number2”，并使用“ Arrays.deepToString（）”关键字打印元素。使用该库之前，您必须导入“ java.util.Arrays”库。

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

考虑输出，

同时，使用两个for循环，可以打印2D元素。谢谢！

Answer 33

在java 8中：

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

Answer 34

如果要打印，请评估数组内容，就像可以使用Arrays.toString

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

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

jshell>

Answer 35

toString是一种将数组转换为字符串的方法。

此外，您可以使用：

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

此for循环将使您能够按顺序打印数组的每个值。

Answer 36

您可以使用Arrays.toString()

String[] array = { "a", "b", "c" };  
System.out.println(Arrays.toString(array));

Answer 37

打印数组的最简单方法是使用for循环：

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

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

37 个答案:

简单数组：

嵌套数组：

`double`数组：

`int`数组：

Arrays.toString

Java 8 - Stream.collect（join（）），Stream.forEach

Java 8之前

Java 8

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

37 个答案:

简单数组：

嵌套数组：

double数组：

int数组：

Arrays.toString

Java 8 - Stream.collect（join（）），Stream.forEach

Java 8之前

Java 8

`double`数组：

`int`数组：