当前位置： 文江博客话题详情

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

发布于 2024-07-10 18:14:56 字数 786 浏览 5 评论 0原文

在 Java 中，数组不会覆盖 toString()，因此，如果您尝试直接打印数组，则会得到 className + '@' + hashCode ，由 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] 的东西。 最简单的方法是什么？ 以下是一些输入和输出示例：

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

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]

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。

评论（30）

别理我 2024-07-17 18:14:56

从 Java 5 开始，您可以使用 Arrays.toString(arr) 或 Arrays.deepToString(arr)< /a> 用于数组中的数组。 请注意，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)); 
  // 给出所需的输出： 
  System.out.println(Arrays.deepToString(deepArray));

    输出：

    <前><代码>[[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
    [[约翰、玛丽]、[爱丽丝、鲍勃]]

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

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"}};
// Gives undesired output:
System.out.println(Arrays.toString(deepArray));
// Gives the desired output:
System.out.println(Arrays.deepToString(deepArray));

    Output:

    [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
[[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 ]
回复 原文
清君侧 2024-07-17 18:14:56

始终首先检查标准库。

import java.util.Arrays;

然后尝试：

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

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

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

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));
回复 原文
伪心 2024-07-17 18:14:56

不过，很高兴知道，至于“始终首先检查标准库”，我永远不会偶然发现 Arrays.toString( myarray ) 的技巧

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

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

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 ) );
回复 原文
腻橙味 2024-07-17 18:14:56

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

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
*/
回复 原文
失与倦＂ 2024-07-17 18:14:56

Arrays.toString

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

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

下面我尝试列出一些建议的其他方法，尝试进行一些改进，其中最值得注意的补充是使用 Stream.collect< /code>运算符，使用 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);

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);
回复 原文
帥小哥 2024-07-17 18:14:56

从 Java 8 开始，还可以利用 String 类 打印出数组元素，不带括号，并用选择的分隔符分隔（这是下面所示示例中的空格字符）：

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

输出将为“Hey there amigo！”。

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!".

回复 原文
负佳期 2024-07-17 18:14:56

在 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[])< /code>，在 int[] 的情况下返回 Stream，然后方法 flatMapToInt() 映射每个元素流的内容，其中包含通过将提供的映射函数应用于每个元素而生成的映射流的内容。

输出是：

[[11, 12], [21, 22], [31, 32, 33]]
[[约翰、布拉沃]、[玛丽、李]、[鲍勃、约翰逊]]
11
12
21
22
31
32
33
约翰
太棒了
玛丽
李
鲍勃
约翰逊

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

回复 原文
非要怀念 2024-07-17 18:14:56

如果您使用的是 Java 1.4，您可以这样做：（

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

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

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

回复 原文
似狗非友 2024-07-17 18:14:56

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

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

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

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

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

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.

回复 原文
回梦 2024-07-17 18:14:56
for(int n: someArray) {
    System.out.println(n+" ");
}

for(int n: someArray) {
    System.out.println(n+" ");
}
回复 原文
枯寂 2024-07-17 18:14:56

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

  1. 简单的方法

    列表<字符串>   列表 = new ArrayList(); 
  列表.add(“一”); 
  list.add("二"); 
  list.add("三"); 
  list.add("四"); 
  // 在控制台中打印列表 
  System.out.println(列表);

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

  1. 使用 toString()

    String[] array = new String[] { "一", "二", "三", "四" }; 
  System.out.println(Arrays.toString(array));

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

  1. 打印数组的数组

    String[] arr1 = new String[] { "第五", "第六" }; 
  String[] arr2 = new String[] { "第七个", "第八个" }; 
  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] [[第五、第六]、[第七、第八]]

资源：访问数组

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]

  1. Using toString()

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

Output: [One, Two, Three, Four]

  1. 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

回复 原文
半﹌身腐败 2024-07-17 18:14:56

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

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

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

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

回复 原文
木森分化 2024-07-17 18:14:56

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

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
}
回复 原文
岁月静好 2024-07-17 18:14:56

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

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

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.outor a PrintWriter for such eventualities.

回复 原文
柠檬色的秋千 2024-07-17 18:14:56

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

  1. ： Arrays.stream(intArray).forEach

  2. 方法参考：::println

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

如果你想在同一行打印数组中的所有元素，那么只需使用 print 而不是 < code>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));

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 i.e.

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));
回复 原文
无人问我粥可暖 2024-07-17 18:14:56

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

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

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
回复 原文
最偏执的依靠 2024-07-17 18:14:56

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

  • 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]]
回复 原文
戏蝶舞 2024-07-17 18:14:56

打印数组有以下几种方式

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

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);
     }
回复 原文
素染倾城色 2024-07-17 18:14:56

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

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

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

打印

abc

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
回复 原文
染火枫林 2024-07-17 18:14:56

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

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

它将打印

1
2
3

Noloops required in this method and it is best for Small arrays only

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

回复 原文
画尸师 2024-07-17 18:14:56

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

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>
回复 原文
酷遇一生 2024-07-17 18:14:56

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

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

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);
回复 原文
檐上三寸雪 2024-07-17 18:14:56

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

使用 Jackson：

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

使用 Gson：

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

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));
回复 原文
为人所爱 2024-07-17 18:14:56
// 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]

// 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]
回复 原文
々眼睛长脚气 2024-07-17 18:14:56

这里是一个可能的打印函数：

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

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

回复 原文
一抹微笑 2024-07-17 18:14:56
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);
        }
      }
    }

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);
        }
      }
    }
回复 原文
痴情换悲伤 2024-07-17 18:14:56

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

如果它包含 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.

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.
回复 原文
恋你朝朝暮暮 2024-07-17 18:14:56

如果您运行的是 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]

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]
回复 原文
情未る 2024-07-17 18:14:56

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

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
回复 原文
浪菊怪哟 2024-07-17 18:14:56

在java 8中：

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

In java 8 :

Arrays.stream(myArray).forEach(System.out::println);
回复 原文
~没有更多了~

关于作者

清醇

暂无简介

0 文章
0 评论
23 人气
发私信

相关话题

更多

热门标签

操作系统 程序设计 IT运维 Linux系统管理 JavaScript 服务器应用 solaris C/C++ PHP Shell BSD Vue.js aix Oracle Python HTML 系统管理 HTML5 CSS 前端
更多

推荐作者

1CH1MKgiKxn9p

文章 0 评论 0

ゞ记忆︶ㄣ

文章 0 评论 0

JackDx

文章 0 评论 0

信远

文章 0 评论 0

yaoduoduo1995

文章 0 评论 0

霞映澄塘

文章 0 评论 0

更多

友情链接

文江博客
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
    原文