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

小开

最佳答案

从Java5开始，您可以对数组中的数组使用#0或#1。请注意，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"}};// Gives undesired output:System.out.println(Arrays.toString(deepArray));// Gives the desired output:System.out.println(Arrays.deepToString(deepArray));

输出：

[[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922][[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 ]

小开

总是先检查标准库。

import java.util.Arrays;

然后尝试：

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

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

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

小开

如果你使用Java1.4，你可以这样做：

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

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

小开

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

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

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

小开

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

小开

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

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

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

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

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

小开

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

的示例代码

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

输出是你的1、2、3、4、5

小开

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

String[] strArray = new String[] {"John", "Mary", "Bob"};
// #1Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));
// #2Stream.of(strArray).forEach(System.out::println);
// #3Arrays.stream(strArray).forEach(System.out::println);
/* output:JohnMaryBob*/

小开

要添加到所有答案中，还可以选择将对象打印为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));

小开

如果你的数组是char[]类型，还有一种额外的方法：

char A[] = {'a', 'b', 'c'};
System.out.println(A); // no other arguments

印刷品

abc

小开

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

小开

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

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

它会打印

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

小开

8Java之前

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

Java8

现在我们有了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 8System.out.println(Arrays.toString(intArray));System.out.println(Arrays.toString(strArray));
// In Java 8 we have lambda expressionsArrays.stream(intArray).forEach(System.out::println);Arrays.stream(strArray).forEach(System.out::println);}

输出是：

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

打印多维阵列如果我们想打印多维数组，我们可以使用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 8System.out.println(Arrays.deepToString(int2DArray));System.out.println(Arrays.deepToString(str2DArray));
// In Java 8 we have lambda expressionsArrays.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()将stream的每个元素映射为通过将提供的映射函数应用于每个元素而产生的映射流的内容。

输出是：

[[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
约翰逊

小开

可以选择使用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>

小开

从Java8开始，还可以利用字符串类提供的join()方法打印出没有括号的数组元素，并由选择的分隔符分隔（这是下面所示示例的空格字符）：

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

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

小开

Arrays.to弦

作为一个直接的答案，使用#0和#1方法的包括@Esko在内的几家公司提供的解决方案是最好的。

Java8-Stream.collect（加入（）），Stream.for

下面我试着列出一些建议的其他方法，试图改进一点，最值得注意的是使用#0运算符，使用#1Collector，模仿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看到这篇文章。写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(..)从Java5开始可用，toString(..)可以很容易地更改为deepToString(..)以添加对包含其他数组的数组的支持。

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

小开

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

小开

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

流：Arrays.stream(intArray).forEach

方法参考：::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);

另一种没有方法引用的方法只是使用：

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 1item 2item 3

小开

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

简单的方法

List<String> list = new ArrayList<String>();list.add("One");list.add("Two");list.add("Three");list.add("Four");// Print the list in consoleSystem.out.println(list);

Output:[One, Two, Three, Four]

Using toString()

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

Output: [One, Two, Three, Four]

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

小开

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

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

小开

有以下方法打印数组

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

小开

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

小开

在java 8中：

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

小开

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

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

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

或者它是否包含UTF-8字符串

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

或者如果你想打印为十六进制。

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

或者如果你想把它打印成Base64。

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

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

String s = Arrays.toString(bytes);System.out.println(s);// to reverseString[] 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 reverseString[] 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.

小开

首先解释一下，什么是数组？

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

class demo{public static void main(String a[]){
int[] number={1,2,3,4,5};
System.out.print(number);}}

现在看看输出，

你可以看到打印了一个未知的字符串…正如我之前提到的，打印了声明数组（数字数组）的内存地址。

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（）”关键字打印元素。

 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元素…谢谢！

小开

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

小开

如果使用lang库，我们可以这样做：

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}

小开

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

此外，您可以使用：

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

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

小开

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

String[] strArray = new String[] {"John", "Mary", "Bob"};
// #1Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));
// #2Stream.of(strArray).forEach(System.out::println);
// #3Arrays.stream(strArray).forEach(System.out::println);
/* output:JohnMaryBob*/

此外，从Java8开始，还可以利用String类提供的连接（）方法打印出数组元素，不带括号，并由选择的分隔符分隔（这是下面显示的示例的空格字符）

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

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

小开

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

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

小开

如果你使用Java11

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.util.数组：

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

输出：[M， XXX， ABC]

小开

这是一种非常简单的方法，无需在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]]

☻♥保持代码

小开

使用数组类。它有多个实用方法，它的toString()被覆盖以人类可读的方式显示数组元素。Arrays.toString(arr)

小开

对于在这里结束的Android开发人员，这是静态编程语言：

println(myArray.joinToString())

或

println(myArray.joinToString(separator = "|"))