在爪哇中，数组不重写EDCOX1×0，因此，如果您试图直接打印一个，则得到EDCOX1(2)所定义的EDCOX1×1的EXOCX1的"十六进制"。

但通常我们会想要更像[1, 2, 3, 4, 5]的东西。最简单的方法是什么？以下是一些输入和输出示例：

由于Java 5，您可以使用数组中的数组的EDCOX1、0、EDCOX1或1。注意，Object[]版本对数组中的每个对象调用.toString()。输出甚至按照您要求的方式进行装饰。

实例：

• 简单数组：

  1 2	String[] array = new String[] {"John","Mary","Bob"}; System.out.println(Arrays.toString(array));

  输出：

  1	[John, Mary, Bob]

• 嵌套数组：

  1 2 3 4 5 6 7

  String[][] deepArray = new String[][] {{"John","Mary <div class="suo-content">[collapse title=""]<ul><li>这也适用于多维数组。</li><li>如果我们有一个字符串数组，想要简单的输出，比如：<wyn>String[] array = {"John","Mahta","Sara"}</wyn>，我们想要这个没有括号和逗号的输出：<wyn>John Mahta Sara</wyn>？</li><li>@ Hengameh：还有其他几种方法可以做到这一点，但我最喜欢的是：JavaHooCalputo.com／Notes／Java.html数组数组ToSt.</li><li>仅供参考，<wyn>Arrays.deepToString()</wyn>只接受<wyn>Object []</wyn>(或扩展<wyn>Object</wyn>的类数组，如<wyn>Integer</wyn>，因此它不适用于<wyn>int []</wyn>类型的原始数组。但是对于原始数组，<wyn>Arrays.toString(<int array>)</wyn>工作得很好。</li><li>@亨加梅有一种方法专门用来解决这个问题。<wyn>System.out.println(String.join("", new String[]{"John","Mahta","Sara"}))</wyn>将打印<wyn>John Mahta Sara</wyn>。</li><li>@Dorukayhan实际上可以在这里省略显式实例化数组：<wyn>.join(...)</wyn>方法的<wyn>String.join("","John","Mahta","Sara")</wyn>将数组作为vararg参数。</li><li>先生，你是男人中的王子。</li></ul>[/collapse]</div><hr> <p> Always check the standard libraries first.  Try: </p> [cc lang="java"]System.out.println(Arrays.toString(array));

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

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

  相关讨论

  • 如果我们有一个字符串数组，想要简单的输出，比如：String[] array = {"John","Mahta","Sara"}，我们想要这个没有括号和逗号的输出：John Mahta Sara？
  • @ Hengameh只将数组、toString(数组)存储到字符串变量中，然后用Java的替换方法移除括号
  • 现在使用Java 8：EDCOX1，14。doc

  ---

  不过，对于"总是先检查标准库"这一点，我很高兴知道，我从来没有遇到过Arrays.toString( myarray )的诀窍。

  --因为我专注于我的阵列的类型来看看如何做到这一点。我不想重复这件事：我想要一个简单的调用，使它的结果与我在Eclipse调试器和myArray.ToString()中看到的结果类似，只是没有这样做。

  1 2 3 4 5

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

  相关讨论

  • 如果我们有一个字符串数组，想要简单的输出，比如：String[] array = {"John","Mahta","Sara"}，我们想要这个没有括号和逗号的输出：John Mahta Sara？
  • @我认为这是另一个话题。您可以在以后使用常见的字符串操作来操作此字符串…like array.toString(myarray).replace("["，"(")等。

  ---

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

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

  相关讨论

  • 或者不那么麻烦，Arrays.stream(strArray).forEach(System.out::println);。
  • 这是笨拙的。它应该是EDCOX1，23，这是Java 8方法的参考。代码产生不必要的lambda。
  • 跳过Arrays.asList，做Arrays.stream(strArray).forEach(System.out::println)。
  • @ AlexisC。更好的是，Stream.of。
  • @Yassinhajaj为什么更好？
  • @ AlexisC。因为它也可以与数组以外的其他对象一起使用。
  • @ yassinhajaj吗是的，但具体来说问题问一个阵列。如果你有一个阵列，它是更好的使用到Arrays.stream比Stream.of。
  • alexisc @。它是在更好的词汇表的性能或只是在该scope这样的问题吗？
  • @ yassinhajaj两种。例如，如果你想有一个流路，在"阵列"的idiomatic方式使用Stream.of会做.skip(n).limit(m)。"当前的实施并没有回报的sized流whereas Arrays.stream(T[], int, int)回家的时候，引导到更好的splitting performances如果你想执行业务，在平行。如果你也有一个int[]，你可能accidentally使用Stream.of将返回的Stream与单元，而Arrays.stream会给你一个IntStream直接。
  • 为什么用Stream如果你想得到的字符串？尤其是，如果Arrays舱toString腹部的方法吗？

  ---

  如果你使用Java 1.4，你可以这样做：

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

  (当然，这也适用于1.5+版本。)

  相关讨论

  • 不幸的是，这只适用于对象数组，而不是基元数组。

  ---

  从Java 8开始，还可以利用String类提供的EDCOX1×12方法来打印数组元素，不带括号，并用选择符分隔符(这是下面所示示例的空格字符)：

  1 2 3

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

  输出将是"嘿，朋友！".

  ---

  数组字符串

  作为一个直接的答案，包括@esko在内的几家公司使用Arrays.toString和Arrays.deepToString方法提供的解决方案，仅仅是最好的。

  Java 8流-收集器(联接())，Stream.forEach

  下面我试着列出一些其他建议的方法，试图改进一点，其中最值得注意的是使用Stream.collect操作符，使用joiningCollector来模拟String.join正在做什么。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  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之前

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

  爪哇8

  现在我们可以选择Stream和lambda来打印阵列。

  打印一维数组：

  1 2 3 4 5 6 7 8 9 10 11 12

  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]
  [John, Mary, Bob]
  1
  2
  3
  4
  5
  John
  Mary
  Bob

  打印多维数组为了防止打印多维数组，我们可以使用Arrays.deepToString(array)作为：

  1 2 3 4

  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 <div class="suo-content">[collapse title=""]<ul><li>   什么，如果我们有一个阵列中的字符串，和想要简单的输出；像：<wyn>String[] array = {"John","Mahta","Sara"}</wyn>，和我们希望这没有输出的支架和commas：<wyn>John Mahta Sara</wyn>吗？   </li></ul>[/collapse]</div><hr><P><wyn>Arrays.deepToString(arr)</wyn>只在一行上打印。</P>[cc lang="java"]int[][] table = new int[2][2];

  为了让一张桌子打印成二维的桌子，我必须这样做：

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

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

  相关讨论

  • 可能使用System.GetProperty("line.separator")；而不是
    ，因此它也适用于非Windows。
  • 现在可以使用System.LineSparator()。

  ---

  1 2 3

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

  相关讨论

  • 这样你最终会得到一个空的空间；)
  • 马蒂亚德。这一行将避免以空格system.out.println结尾(n+(somearray.length==n)？：""
  • 最糟糕的方法。
  • 这是如此低效，但对初学者有好处。
  • @穆罕默斯勒曼不起作用，因为这是一个为每个循环。n是数组的实际值，而不是索引。对于常规for循环，它也将是(someArray.length - 1) == i，因为当i等于数组长度时，它将中断。

  ---

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

• 简单方法

  1 2 3 4 5 6 7

  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]

• 使用toString()。

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

Output: [One, Two, Three, Four]

• 打印数组数组

  1 2 3 4 5 6

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

资源：访问阵列

---

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

1 2 3

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

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

相关讨论

• 它输出"1，2，3，4，5"，最后一个元素后面也输出逗号。
• 最后一个元素后面没有逗号的解决方案是什么？
• 您可以用System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(",");替换循环中的代码。
• 您也可以使用System.out.print(i + (i < intArray.length - 1 ?"," :""));组合这两条线。
• 可以使用StringBuilder并截断尾随逗号。int[]intarray=new int[]1，2，3，4，5 final stringbuilder sb=new stringbuilder()；for(int i:intarray)sb.append(intarray[i]).append("，)；if(sb.length()>0)sb.setlength(sb.length()-1)；system.out.println(sb.tostring())；此输出"1，2，3，4，5"。

---

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

• 流：Arrays.stream(intArray).forEach。

• 方法参考：::println。

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

如果要在同一行中打印数组中的所有元素，那么只需使用print而不是println，即。

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

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

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

相关讨论

• 这将打印每一元的阵列上的separate线，所以它并不是会见的要求。
• 如果你想打印的所有元素在阵列在相同的线，然后使用打印代替println公元前intarray = int int [ ]在[ ] { 1，2，3，4，5 arrays.stream }；(intarray).foreach(system.out：：打印)；antotherway没有methodreference只是使用int [ ]在intarray = int(){ 1，2，3，4，5 system.out.println }；(arrays.tostring(intarray))；

---

无论您使用哪种JDK版本，它都应该始终有效：

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

如果Array包含对象，它将工作。如果Array包含基元类型，则可以使用包装类，而不是将基元直接存储为..

例子：

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

替换为：

1	Integer[] a = new Integer[]{1,2,3,4,5};

更新：

对！值得一提的是，将数组转换为对象数组或使用对象数组的成本很高，可能会降低执行速度。它发生在Java的本质上称为自动装箱。

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

1 2 3

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

相关讨论

• 一个converting阵列到列表的单纯为印刷用途并不是看起来像是一个非常resourceful决策；和在那相同的腹舱的toString(..)，它defeats我为什么有人会这样做。

---

我最近在《香草》杂志上偶然发现了这个帖子。写Arrays.toString(arr);不太方便，一直导入java.util.Arrays;。

请注意，这不是任何方式的永久性修复。只是一个可以简化调试的黑客。

直接打印数组会给出内部表示和哈希代码。现在，所有类都将Object作为父类型。那么，为什么不入侵Object.toString()？不进行修改，对象类如下所示：

1 2 3

public String toString() {     return getClass().getName() +"@" + Integer.toHexString(hashCode()); }

如果改为：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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

通过向命令行添加以下内容，可以简单地将这个moded类添加到类路径中：-Xbootclasspath/p:target/classes。

现在，随着Java 5的EDCOX1 5的可用性，EDCOX1的6度可以很容易地被更改为EDCOX1×5，以增加对包含其他数组的数组的支持。

我发现这是一个非常有用的黑客，如果Java可以简单地添加它，那就太棒了。我了解拥有非常大的数组的潜在问题，因为字符串表示可能有问题。可能通过类似于System.out或PrintWriter这样的事件。

相关讨论

• 你想execute if这些条件在每一对象吗？
• + 1 * *的想法，但基于previous评论，我们可以implementations mod的阵列而不是直接取决于上的Object常见的父吗？我们可以工作，进一步的想法了吗？不，我认为这modifying违约behavior of java.lang。*的物体是什么我会encourage………………

---

要添加到所有答案中，将对象打印为JSON字符串也是一个选项。

使用杰克逊：

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

使用Gson：

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

相关讨论

• 这就是我做的。有了这个，你可以打印arbitrarily复杂结构物只要他们在encodable到json。我总是让肯定到用"漂亮"。你的第二个例子确实这样做吗？我认为你需要(D - tickle是"漂亮"的选项，得到。

---

如果数组类型为char[]，则还有一种方法：

1 2 3

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

印刷品

1

abc

---

我尝试过的一个简单快捷方式是：

1 2 3 4

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

它会打印出来

1 2 3

1 2 3

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

---

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

1 2 3 4 5 6 7

String[] items = {"item 1","item 2","item 3"}; for(int i = 0; i < items.length; i++) {     System.out.println(items[i]); }

输出：

1 2 3

item 1 item 2 item 3

---

打印数组的方法如下

1 2 3 4 5 6 7 8 9 10 11 12 13

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

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

---

对于每个循环，还可以使用打印数组元素：

1 2 3

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

相关讨论

• @ firephil system.out.println(()))；用与一般为环，在指数"I"雅和价值的美元指数的每一个印刷。我用"为每一个"环。给它一个尝试，希望你会让我的点。
• 是的，这就是shortest方式来打印阵列

---

Using org.apache.commons.lang3.StringUtils.join(*) methods can be an option
For example:

1 2 3 4

String[] strArray = new String[] {"John","Mary","Bob" }; String arrayAsCSV = StringUtils.join(strArray," ,"); System.out.printf("[%s]", arrayAsCSV); //output: [John , Mary , Bob]

我使用了以下依赖项

1 2 3

<groupId>org.apache.commons</groupId> commons-lang3</artifactId> <version>3.3.2</version>

---

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

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

1 2 3 4

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

或者如果它包含一个utf-8字符串

1 2 3 4

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

或者如果你想把它打印成十六进制。

1 2 3 4

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

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

1 2 3 4

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

或者如果要打印一个有符号字节值数组

1 2 3 4 5 6 7

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

或者如果要打印一个无符号字节值数组

1 2 3 4 5 6 7 8

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 2 3 4 5 6

// array of primitives: int[] intArray = new int[] {1, 2, 3, 4, 5}; System.out.println(Arrays.toString(intArray)); output: [1, 2, 3, 4, 5]

1 2 3 4 5 6

// array of object references: String[] strArray = new String[] {"John","Mary","Bob"}; System.out.println(Arrays.toString(strArray)); output: [John, Mary, Bob]

---

在Java 8中：

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

---

如果使用commons.lang库，我们可以做到：

ArrayUtils.toString(array)

1 2 3 4

int[] intArray = new int[] {1, 2, 3, 4, 5}; String[] strArray = new String[] {"John","Mary","Bob"}; ArrayUtils.toString(intArray); ArrayUtils.toString(strArray);

输出：

1 2	{1,2,3,4,5} {John,Mary,Bob}

---

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

好的，我将创建这样的数组，

1 2 3 4 5 6 7 8

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

现在看看输出，



您可以看到一个未知的字符串被打印出来。正如我前面提到的，其数组(数字数组)声明的内存地址被打印出来了。如果您想在数组中显示元素，可以使用"for loop"，就像这样。

1 2 3 4 5 6 7 8 9 10 11 12

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

现在看看输出，



好，成功地打印了一维数组的元素。现在我要考虑二维数组。我将声明二维数组为"数字2"，并使用"Surrest.StuttoStRun()"关键字打印元素。在使用之前，你必须导入"java. U.L.Star"库。

1 2 3 4 5 6 7 8 9 10

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循环，可以打印二维元素..谢谢！

相关讨论

• 阵列(int)= { 1，2，3，4，5)；为(int)：阵列)system.out.println(I)；
• 试着这样的我想这shortest方式来打印阵列

---

如果您运行的是JDK 8。

1 2 3 4 5 6 7 8 9

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

输出：

1	[7,3,5,1,3]

相关讨论

• 这比接受的答案，它在给更多的控制在"delimiter，前缀和suffix。然而，我remove superfluous toString()在最终System.out.println()并用它在joiner.add(element.toString())代替添加的空字符串。这个解决方案，为工程arrays之非primitive类型为好，uniformly。
• 我的坏的，element.toString()内部joiner.add()也为非primitive唯一的类型。你仍然需要使用Integer.toString(element)=构建为primitive类型。personally，我用foreach环for (int element : array) joiner.add(Integer.toString(element));代替流，但*这是质的味道。

---

如果要打印，可以使用Arrays.toString这样评估数组内容。

1 2 3 4 5 6 7

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

---

你可以用Arrays.toString()。

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

---

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

1 2 3 4 5

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

相关讨论

• "是的先生为环，assuming的T[] myArray，也for (int i = 0; i < myArray.length; i++) { System.out.println(myArray[i] +""); }

---