csdnceshi79
python小菜
2009-01-03 20:39
采纳率: 0%
浏览 1.2k
已采纳

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

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]

转载于:https://stackoverflow.com/questions/409784/whats-the-simplest-way-to-print-a-java-array

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

29条回答 默认 最新

  • csdnceshi63
    elliott.david 2012-10-03 08:51
    已采纳

    Since Java 5 you can use Arrays.toString(arr) for simple arrays or Arrays.deepToString(arr) for nested 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"}};
    System.out.println(Arrays.toString(deepArray));
    //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
    System.out.println(Arrays.deepToString(deepArray));
    

    Output:

    [[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 ]
    
    点赞 评论
  • csdnceshi70
    笑故挽风 2009-01-03 20:48

    Always check the standard libraries first. Try:

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

    or if your array contains other arrays as elements:

    System.out.println(Arrays.deepToString(array));
    
    点赞 评论
  • csdnceshi58
    Didn"t forge 2009-01-03 21:44

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

    点赞 评论
  • weixin_41568183
    零零乙 2010-05-12 21:01

    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 ) );
    
    点赞 评论
  • csdnceshi59
    ℙℕℤℝ 2011-01-24 04:25
    for(int n: someArray) {
        System.out.println(n+" ");
    }
    
    点赞 评论
  • csdnceshi79
    python小菜 2013-10-05 19:13

    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.

    点赞 评论
  • csdnceshi63
    elliott.david 2013-12-27 23:31

    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

    点赞 评论
  • csdnceshi56
    lrony* 2014-02-06 23:35

    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
    */
    
    点赞 评论
  • csdnceshi57
    perhaps? 2014-04-29 07:34

    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
    
    点赞 评论
  • weixin_41568126
    乱世@小熊 2014-09-21 09:11
    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);
            }
          }
        }
    
    点赞 评论
  • csdnceshi72
    谁还没个明天 2015-02-17 08:02

    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

    点赞 评论
  • weixin_41568196
    撒拉嘿哟木头 2015-06-19 06:10

    Prior to Java 8 we could have used Arrays.toString(array) to print one dimensional array and Arrays.deepToString(array) for multi-dimensional arrays. We have got the option of Stream and lambda in Java 8 which can also be used for the printing 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

    点赞 评论
  • csdnceshi57
    perhaps? 2015-08-06 11:24

    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>
    
    点赞 评论
  • csdnceshi57
    perhaps? 2015-10-01 03:12

    The simplest way to print an array is to use a for-loop:

    // initialize array
    for(int i=0;i<array.length;i++)
    {
        System.out.print(array[i] + " ");
    }
    
    点赞 评论
  • weixin_41568183
    零零乙 2015-12-23 18:51

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

    点赞 评论
  • csdnceshi53
    Lotus@ 2016-03-11 05:36

    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);
    
    点赞 评论
  • csdnceshi75
    衫裤跑路 2016-03-11 11:50

    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.

    点赞 评论
  • csdnceshi68
    local-host 2016-05-13 11:01

    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
    } 
    
    点赞 评论
  • csdnceshi69
    YaoRaoLov 2016-06-26 15:30

    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));
    
    点赞 评论
  • csdnceshi57
    perhaps? 2016-07-20 23:55

    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
    
    点赞 评论
  • csdnceshi77
    狐狸.fox 2016-08-07 14:05

    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

    点赞 评论
  • csdnceshi66

    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);
    
    点赞 评论
  • weixin_41568174
    from.. 2017-09-25 13:29

    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);
         }
    
    点赞 评论
  • csdnceshi63
    elliott.david 2017-12-20 08:52

    You could use Arrays.toString()

    String[] array = { "a", "b", "c" };  
    System.out.println(Arrays.toString(array));
    
    点赞 评论
  • weixin_41568127
    ?yb? 2018-03-16 01:17
    // 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]
    
    点赞 评论
  • weixin_41568110
    七度&光 2018-04-20 18:25

    In java 8 :

    Arrays.stream(myArray).forEach(System.out::println);
    
    点赞 评论
  • csdnceshi70
    笑故挽风 2018-06-22 19:17

    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.
    
    点赞 评论
  • csdnceshi54
    hurriedly% 2018-07-01 15:45

    There are several ways to print an array elements.First of all, I'll explain that, what is an array?..Array is a simple data structure for storing data..When you define an array , Allocate set of ancillary memory blocks in RAM.Those memory blocks are taken one unit ..

    Ok, I'll create an array like this,

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

    Now look at the output,

    enter image description here

    You can see an unknown string printed..As I mentioned before, the memory address whose array(number array) declared is printed.If you want to display elements in the array, you can use "for loop " , like this..

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

    Now look at the output,

    enter image description here

    Ok,Successfully printed elements of one dimension array..Now I am going to consider two dimension array..I'll declare two dimension array as "number2" and print the elements using "Arrays.deepToString()" keyword.Before using that You will have to import 'java.util.Arrays' library.

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

    consider the output,

    enter image description here

    At the same time , Using two for loops ,2D elements can be printed..Thank you !

    点赞 评论
  • weixin_41568196
    撒拉嘿哟木头 2018-07-06 12:29

    If you want to print, evaluate Array content like that you can use Arrays.toString

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

相关推荐