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


1942

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

8
您希望除字符串以外的对象的表示形式是什么?调用toString的结果?是否用引号引起来?
乔恩·斯基特

3
是的,对象将由其toString()方法表示,并且不带引号(只需编辑示例输出)。
Alex Spurling,2009年


1
该奇怪的输出不一定是内存位置。这是hashCode()十六进制。请参阅Object#toString()
4castle

1
要在java8中打印一维或多维数组,请检查stackoverflow.com/questions/409784/…–
akhil_mittal

Answers:


2599

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

3
如果我们有一个字符串数组,想要简单的输出怎么办?像:String[] array = {"John", "Mahta", "Sara"},我们希望没有支架和逗号此输出:John Mahta Sara
亨伽美

3
@Hengameh:还有其他几种方法可以做到这一点,但是我最喜欢的是这种方法:javahotchocolate.com/notes/java.html#arrays-tostring
罗斯·贝特曼

5
仅供参考,Arrays.deepToString()仅接受Object [](或扩展的类的数组Object,例如Integer,因此它不适用于类型的原始数组int []。但是Arrays.toString(<int array>)对原始数组有效
Marcus

4
@Hengameh有专门的方法。System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))将打印John Mahta Sara
user8397947年

2
@dorukayhan实际上,您可以在此处省略显式实例化该数组:String.join(" ", "John", "Mahta", "Sara")因为该.join(...)方法将数组作为vararg参数。
阿马丹'18

354

始终首先检查标准库。

import java.util.Arrays;

然后尝试:

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

或者您的数组包含其他数组作为元素:

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

如果我们有一个字符串数组,想要简单的输出怎么办?像:String[] array = {"John", "Mahta", "Sara"},我们希望没有支架和逗号此输出:John Mahta Sara
Hengameh 2015年

1
@Hengameh只需将Arrays.toString(array)存储到一个字符串变量,然后通过Java的replace方法删除花括号
Naveed Ahmad

12
@Hengameh时下Java 8 :String.join(" ", Arrays.asList(array))doc
贾斯汀

106

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

-因为我一直专注于myarray的类型以了解如何执行此操作。我不想遍历这件事:我想要一个简单的调用来使其类似于Eclipse调试器中看到的内容,而myarray.toString()并未这样做。

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

如果我们有一个字符串数组,想要简单的输出怎么办?像:String[] array = {"John", "Mahta", "Sara"},我们希望没有支架和逗号此输出:John Mahta Sara
Hengameh 2015年

3
@Hengameh我认为这是另一个话题。之后,您可以使用常见的字符串操作来操作此String ...就像Arrays.toString(myarray).replace(“ [”,“(”);等)
OddDev

91

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

50
还是不太麻烦,Arrays.stream(strArray).forEach(System.out::println);
Alexis C.

9
笨拙的 应该System.out::println是Java 8方法参考。您的代码会产生不必要的lambda。
蜘蛛鲍里斯(Boris)

2
只需跳过Arrays.asList并执行Arrays.stream(strArray).forEach(System.out::println)
贾斯汀

1
@AlexisC。因为它也可以与数组以外的其他对象一起使用。
Yassin Hajaj

1
@YassinHajaj两者。例如,如果要在数组上有范围流,则惯用的方法Stream.of是do .skip(n).limit(m)。当前实现不返回SIZED流,而是返回SIZED流Arrays.stream(T[], int, int),如果您要并行执行操作,则可以实现更好的拆分性能。另外,如果您有一个int[],则可能会不小心使用Stream.of它将返回Stream<int[]>带有单个元素的,而Arrays.streamIntStream直接给您一个。
Alexis C.

41

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

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

输出将是“嘿,朋友!”。


40

如果您使用的是Java 1.4,则可以执行以下操作:

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

(当然,这也适用于1.5+。)


38
不幸的是,这仅适用于对象数组,而不适用于图元数组。
Alex Spurling,2009年

34

Arrays.toString

直接的答案是,包括@Esko在内的几个人使用Arrays.toStringArrays.deepToString方法提供的解决方案简直是最好的。

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

下面,我尝试列出一些建议的其他方法,尝试进行一些改进,最值得注意的增加是使用Stream.collect运算符(使用)来模仿的功能。joining CollectorString.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);

33

Java 8之前的版本

我们本来可以Arrays.toString(array)打印一维数组,也可以打印Arrays.deepToString(array)多维数组。

Java 8

现在,我们可以选择Streamlambda打印数组。

打印一维数组:

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

·鲍勃·
约翰逊


如果我们有一个字符串数组,想要简单的输出怎么办?像:String[] array = {"John", "Mahta", "Sara"},我们希望没有支架和逗号此输出:John Mahta Sara
亨伽美

28

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

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

为了使表格实际打印为二维表格,我必须这样做:

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

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


3
也许使用System.getProperty(“ line.separator”); 而不是\ r \ n,因此同样适用于非Windows。
踏板车

您现在就可以使用System.lineSeparator()
Novaterata

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

6
这样,您最终会得到一个空白;)
Matthias 2014年

1
@ matthiad ..这行将避免以空格结尾System.out.println(n +(someArray.length == n)?“”:“”);
穆罕默德·苏莱曼

3
最糟糕的方式。
NameNotFoundException 2015年

@MuhammadSuleman那是行不通的,因为这是一个for-each循环。n是数组中的实际值,而不是索引。对于常规的for循环,它也将是(someArray.length - 1) == i,因为它在i等于数组长度时会中断。
Radiodef

17

用Java打印数组的不同方法:

  1. 简单方法

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

输出:[1、2、3、4]

  1. 使用 toString()

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

输出:[1、2、3、4]

  1. 打印阵列

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

资源:访问数组


13

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

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

它输出为您的1,2,3,4,5


4
它输出“ 1、2、3、4、5”作为输出,在最后一个元素之后也输出逗号。
icza 2014年

在最后一个元素后不加逗号的解决方案是什么?
蒙娜·贾拉勒

3
您可以将循环内的代码替换为System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
Nepoxx,2014年

2
您也可以System.out.print(i + (i < intArray.length - 1 ? ", " : ""));用来合并这两行。
尼克·苏温

您可以使用StringBuilder并截断尾随逗号。int [] intArray = new int [] {1,2,3,4,5}; 最终的StringBuilder sb = new StringBuilder(); for(int i:intArray){sb.append(intArray [i])。append(“,”); }如果(sb.length()> 0){sb.setLength(sb.length()-1); } System.out.println(sb.toString()); 输出“ 1、2、3、4、5”。
Rick Ryker

8

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

现在,随着deepToString(..)Java 5的推出,toString(..)可以轻松更改deepToString(..)为添加对包含其他数组的数组的支持。

我发现这是一个非常有用的技巧,如果Java可以简单地添加它,那就太好了。我理解具有非常大的数组的潜在问题,因为字符串表示形式可能会出现问题。可能会通过诸如a System.out或a之类的事件PrintWriter来传递此类事件。


2
您想if对每个对象执行这些条件?
sidgate '16

+1只是为了这个想法,但基于前面的评论,我们可以直接修改数组实现,而不是依赖于Object公共父级吗?我们可以进一步推广这个想法吗?不是我认为修改java.lang。*对象的默认行为是我鼓励的事情……
YoYo

8

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

1
仅出于打印目的将Array转换为List似乎并不十分明智。并且鉴于同一个班级有一个toString(..),这使我无法理解为什么有人会这样做。
Debosmit Ray

8

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

  1. 流: Arrays.stream(intArray).forEach
  2. 方法参考: ::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));

1
这会将数组的每个元素打印在单独的一行上,因此不符合要求。
Alex Spurling

如果您想在同一行中打印数组中的所有元素,则只需使用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));
suatCoskun

6

如果您的数组为char []类型,则还有另一种方法:

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

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

版画

abc

5

要添加所有答案,将对象打印为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。我总是确保使用“漂亮”。您的第二个示例是否这样做?我认为您需要为该选项添加一个“漂亮”选项。
史蒂夫,

5

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

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

5

有以下方式打印数组

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

4

我尝试过的一个简化的快捷方式是:

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

它将打印

1
2
3

这种方法不需要循环,最好仅适用于小型阵列


4

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”循环。试试看,希望您能理解我的意思。
hasham.98 2013年

是的,这是打印阵列的最短方法
Manjitha teshara

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

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>

由于在两行代码中完成了一些琐碎的事情而添加了一个依赖项,这是一个尖叫的反模式。
jurez

commons-lang3是一个非常受欢迎的依赖项,请注意,这个答案是大多数人不使用Java 8的原因
Haim Raman

2

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

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

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

1

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

这比公认的答案要好,因为它可以更好地控制定界符,前缀和后缀。但是,我将toString()在决赛中删除多余的部分System.out.println()并在其中使用它,joiner.add(element.toString())而不是添加空字符串。该解决方案也同样适用于非基本类型的数组。
约翰·麦克莱恩

我的缺点是,element.toString()内部joiner.add()仅用于非基本类型。您仍然需要使用Integer.toString(element)-类似原始类型的构造。就我个人而言,我使用foreach循环for (int element : array) joiner.add(Integer.toString(element));而不是流,但这就是趣味性。
约翰·麦克莱恩

0

在Java 8中:

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

0

如果使用Commons.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}

0

//如果您使用Java在控制台上打印数组元素的地址。

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

这似乎无法回答问题。
用户

-1

有几种打印数组元素的方法。首先,我将解释什么是数组?.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元素。谢谢!


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

试试这个,我认为这是打印数组的最短方法
Manjitha teshara

“打印声明了其array(number array)的内存地址”完全不对,它是对象的系统哈希码,这可以基于很多东西,包括内存地址,但是以后可能会更改,并且哈希码不会更改。目前,它主要是一个随机数。gotofinal.dev/java/2017/10/08/java-default-hashcode.html
GotoFinal
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.