提问



在Java中,数组不会覆盖toString(),所以如果你试图直接打印一个,你得到className + @ +数组的hashCode的十六进制,由Object.toString()定义]]:[112]


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]

最佳参考


从Java 5开始,您可以将Arrays.toString(arr)Arrays.deepToString(arr)用于数组中的数组。请注意,Object[]版本在数组中的每个对象上调用.toString()。输出甚至以您要求的确切方式进行装饰。[113] [114]


例子:


简单数组:



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 ]

其它参考1


始终先检查标准库。尝试:


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


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


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

其它参考2


然而,很高兴知道,总是首先检查标准库我从来没有偶然发现Arrays.toString( myarray )的伎俩


- 因为我专注于myarray的类型,看看如何做到这一点。我不想迭代这件事:我想要一个简单的调用,使它与我在Eclipse调试器中看到的类似,而myarray.toString()只是没有做到。


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

其它参考3


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

其它参考4


如果你正在使用Java 1.4,你可以改为:


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


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

其它参考5


从Java 8开始,人们还可以利用String类提供的join()方法打印出数组元素,不带括号,并用选择的分隔符分隔(这是所示示例的空格字符)下图):[115]


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


输出将是嘿有amigo!。

其它参考6


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


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


要实际将表打印为二维表,我必须这样做:


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


似乎Arrays.deepToString(arr)方法应该采用分隔符字符串,但遗憾的是它并没有。

其它参考7


Arrays.toString



作为一个直接的答案,包括@Esko在内的几个人使用Arrays.toStringArrays.deepToString方法提供的解决方案是最好的。 [117] [118]


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



下面我尝试列出一些建议的其他方法,尝试改进一点,最显着的添加是使用Stream.collect运算符,使用joining Collector来模仿String.join正在做什么。[119] [120]


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

其它参考8


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

  [[约翰,布拉沃]],[[玛丽,李]],[[鲍勃,约翰逊]]

  11个结果
  12个结果
  21个结果
  22个结果
  31个结果
  32个结果
  33个结果
  约翰点击
  布拉沃结果
  玛丽结果
  李点击
  鲍勃结果
  约翰逊


其它参考9


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

其它参考10


在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. 使用 toString()


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




  输出:[[一,二,三,四]]




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



资源:访问数组[121]

其它参考11


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


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


它提供输出作为你的
    1,2,3,4,5

其它参考12


我最近在Vanilla #Java中看过这篇文章。写Arrays.toString(arr);,然后一直导入java.util.Arrays;不是很方便。[122]


请注意,这绝不是永久性修复。只是一个可以简化调试的黑客。


直接打印数组会给出内部表示和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.outPrintWriter的内容。

其它参考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
} 

其它参考14


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



  1. stream: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));

其它参考15


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


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

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


版画


abc

其它参考16


要添加到所有答案,将对象打印为JSON字符串也是一种选择。


使用杰克逊:


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


使用Gson:


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

其它参考17


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


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


它会打印出来


1
2
3


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

其它参考18


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


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

其它参考19


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

其它参考20


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

其它参考21


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


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

其它参考22


有以下方式打印数组


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

其它参考23


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

其它参考24


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


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

其它参考25


在java 8中:


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

其它参考26


打印数组元素有几种方法。首先,我将解释一下,什么是数组?数组是一个用于存储数据的简单数据结构。当你定义一个数组时,分配一组辅助内存块在RAM中。这些内存块占一个单位..


好的,我会创建一个这样的数组,


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

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

           System.out.print(number);
      }
}


现在看看输出,


[124]


你可以看到一个未知的字符串打印。正如我之前提到的那样,打印其数组(数组数组)的内存地址。如果你想在数组中显示元素,你可以使用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]+"  ");
           }
      }
}


现在看看输出,


[125]


好的,成功打印了一维数组的元素。现在我要考虑二维数组。我将声明二维数组为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));
      }
}


考虑输出,


[126]


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

其它参考27


如果要打印,请评估可以使用Arrays.toString的数组内容


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

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

jshell> 

其它参考28


你可以用Arrays.toString()


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

其它参考29


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


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