Cách đơn giản nhất để in một mảng Java là gì?

Trong Java, các mảng không ghi đè toString(), vì vậy nếu bạn cố in trực tiếp, bạn sẽ nhận được className+ '@' + hex của hashCodemảng, như được định nghĩa bởi Object.toString():

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

Nhưng thông thường, chúng ta thực sự muốn một cái gì đó giống như [1, 2, 3, 4, 5]. Cách đơn giản nhất để làm điều đó là gì? Dưới đây là một số ví dụ đầu vào và đầu ra:

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

Vì Java 5, bạn có thể sử dụng Arrays.toString(arr)hoặc Arrays.deepToString(arr)cho các mảng trong các mảng. Lưu ý rằng Object[]phiên bản gọi .toString()trên từng đối tượng trong mảng. Đầu ra thậm chí được trang trí theo cách chính xác mà bạn yêu cầu.

Ví dụ:

• Mảng đơn giản:

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

  Đầu ra:

  [John, Mary, Bob]

• Mảng lồng nhau:

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

  Đầu ra:

  [[John, Mary], [Alice, Bob]]

• double Mảng:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));
  

  Đầu ra:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Mảng:

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

  Đầu ra:

  [7, 9, 5, 1, 3 ]

Luôn luôn kiểm tra các thư viện tiêu chuẩn đầu tiên.

import java.util.Arrays;

Vậy hãy thử đi:

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

hoặc nếu mảng của bạn chứa các mảng khác dưới dạng các phần tử:

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

Tuy nhiên, điều này rất tốt để biết vì "luôn luôn kiểm tra các thư viện tiêu chuẩn trước tiên" Tôi chưa bao giờ vấp phải mánh khóe của Arrays.toString( myarray )

--since tôi đang tập trung vào loại myarray để xem cách làm điều này. Tôi không muốn phải lặp đi lặp lại điều này: Tôi muốn một cuộc gọi dễ dàng để làm cho nó phát ra tương tự như những gì tôi thấy trong trình gỡ lỗi Eclipse và myarray.toString () không thực hiện được.

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

Trong JDK1.8, bạn có thể sử dụng các phép toán tổng hợp và biểu thức 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
*/

Bắt đầu với Java 8, người ta cũng có thể tận dụng join()phương thức được cung cấp bởi lớp String để in ra các phần tử mảng, không có dấu ngoặc và được phân tách bằng dấu phân cách lựa chọn (là ký tự khoảng trắng cho ví dụ hiển thị bên dưới):

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

Đầu ra sẽ là "Hey amigo!".

Nếu bạn đang sử dụng Java 1.4, thay vào đó bạn có thể thực hiện:

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

(Tất nhiên, nó cũng hoạt động trong 1.5+.)

Mảng.toString

Là một câu trả lời trực tiếp, giải pháp được cung cấp bởi một số người, bao gồm @Esko , sử dụng phương thức Arrays.toStringvà Arrays.deepToString, đơn giản là tốt nhất.

Java 8 - Stream.collect (tham gia ()), Stream.forEach

Dưới đây tôi cố gắng liệt kê một số phương pháp khác được đề xuất, cố gắng cải thiện một chút, với sự bổ sung đáng chú ý nhất là việc sử dụng Stream.collecttoán tử, sử dụng a , để bắt chước những gì đang làm.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);

Trước Java 8

Chúng ta có thể đã sử dụng Arrays.toString(array)để in mảng một chiều và Arrays.deepToString(array)cho mảng nhiều chiều.

Java 8

Bây giờ chúng ta đã có tùy chọn Streamvà lambdađể in mảng.

In mảng một chiều:

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

Đầu ra là:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

In mảng nhiều chiều Chỉ trong trường hợp chúng tôi muốn in mảng đa chiều, chúng tôi có thể sử dụng Arrays.deepToString(array)như:

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

Bây giờ, điểm cần quan sát là phương thức Arrays.stream(T[]), trong trường hợp int[]trả về cho chúng ta Stream<int[]>và sau đó phương thức flatMapToInt()ánh xạ từng phần tử của luồng với nội dung của luồng được ánh xạ được tạo bằng cách áp dụng hàm ánh xạ được cung cấp cho từng phần tử.

Đầu ra là:

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

Arrays.deepToString(arr) chỉ in trên một dòng.

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

Để thực sự có được một bảng để in dưới dạng bảng hai chiều, tôi đã phải làm điều này:

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

Có vẻ như Arrays.deepToString(arr)phương thức này cần một chuỗi phân tách, nhưng thật không may, nó không có.

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

Các cách khác nhau để in Mảng trong Java:

1. Cách đơn giản

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

Đầu ra: [Một, Hai, Ba, Bốn]

2. Sử dụng toString()

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

Đầu ra: [Một, Hai, Ba, Bốn]

3. Mảng in mảng

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

Đầu ra: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Thứ năm, Thứ sáu], [Thứ bảy, Thứ tám]]

Tài nguyên: Truy cập một mảng

Sử dụng đều đặn cho vòng lặp là cách đơn giản nhất của in mảng theo ý kiến của tôi. Ở đây bạn có một mã mẫu dựa trên intArray của bạn

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

Nó cung cấp đầu ra như của bạn 1, 2, 3, 4, 5

Tôi đã xem qua bài đăng này trong Vanilla #Java gần đây. Nó không phải là rất thuận tiện bằng văn bản Arrays.toString(arr);, sau đó nhập khẩu java.util.Arrays;tất cả các thời gian.

Xin lưu ý, đây không phải là một sửa chữa vĩnh viễn bằng bất kỳ phương tiện. Chỉ cần một hack có thể làm cho việc gỡ lỗi đơn giản hơn.

In một mảng trực tiếp cung cấp cho đại diện nội bộ và hashCode. Bây giờ, tất cả các lớp có Objectkiểu cha. Vì vậy, tại sao không hack Object.toString()? Không sửa đổi, lớp Object trông như thế này:

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

Điều gì xảy ra nếu điều này được thay đổi thành:

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

Lớp được sửa đổi này có thể chỉ cần được thêm vào đường dẫn lớp bằng cách thêm dòng sau vào dòng lệnh : -Xbootclasspath/p:target/classes.

Bây giờ, với tính khả dụng của deepToString(..)Java 5, toString(..)có thể dễ dàng thay đổi deepToString(..)để thêm hỗ trợ cho các mảng có chứa các mảng khác.

Tôi thấy đây là một hack khá hữu ích và thật tuyệt nếu Java có thể chỉ cần thêm nó. Tôi hiểu các vấn đề tiềm ẩn với việc có các mảng rất lớn vì các biểu diễn chuỗi có thể có vấn đề. Có thể vượt qua một cái gì đó như một System.outhoặc một PrintWritercho các tình huống như vậy.

Nó sẽ luôn hoạt động cho dù bạn sử dụng phiên bản JDK nào:

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

Nó sẽ hoạt động nếu Arraychứa các Đối tượng. Nếu Arraychứa các kiểu nguyên thủy, bạn có thể sử dụng các lớp bao bọc thay vì lưu trữ trực tiếp nguyên thủy như ..

Thí dụ:

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

Thay thế bằng:

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

Cập nhật:

Đúng ! điều này được đề cập đến là việc chuyển đổi một mảng thành một mảng đối tượng HOẶC để sử dụng mảng của Object là tốn kém và có thể làm chậm quá trình thực thi. nó xảy ra bởi bản chất của java được gọi là autoboxing.

Vì vậy, chỉ cho mục đích in ấn, nó không nên được sử dụng. chúng ta có thể tạo một hàm lấy một mảng làm tham số và in định dạng mong muốn như

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

Trong java 8 thật dễ dàng. có hai từ khóa

1. suối: Arrays.stream(intArray).forEach

2. tham khảo phương pháp: ::println

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

Nếu bạn muốn in tất cả các thành phần trong mảng trong cùng một dòng, thì chỉ cần sử dụng printthay vì printlntức là

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

Một cách khác không có tham chiếu phương thức chỉ sử dụng:

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

Có một cách bổ sung nếu mảng của bạn thuộc kiểu char []:

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

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

in

abc

Để thêm vào tất cả các câu trả lời, in đối tượng dưới dạng chuỗi JSON cũng là một tùy chọn.

Sử dụng Jackson:

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

Sử dụng Gson:

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

Bạn có thể lặp qua mảng, in ra từng mục, khi bạn lặp. Ví dụ:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

Đầu ra:

item 1
item 2
item 3

Có những cách sau để in 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);
     }

Một phím tắt đơn giản mà tôi đã thử là:

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

Nó sẽ in

1
2
3

Không có vòng lặp cần thiết trong phương pháp này và tốt nhất chỉ dành cho các mảng nhỏ

Đối với mỗi vòng lặp cũng có thể được sử dụng để in các phần tử của mảng:

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

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

Sử dụng các phương thức org.apache.commons.lang3.StringUtils.join (*) có thể là một tùy chọn
Ví dụ:

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

Tôi đã sử dụng phụ thuộc sau đây

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

Điều này được đánh dấu là một bản sao để in một byte [] . Lưu ý: đối với một mảng byte có các phương thức bổ sung có thể phù hợp.

Bạn có thể in nó dưới dạng Chuỗi nếu nó chứa ký tự ISO-8859-1.

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

hoặc nếu nó chứa chuỗi UTF-8

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

hoặc nếu bạn muốn in nó dưới dạng thập lục phân.

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

hoặc nếu bạn muốn in nó dưới dạng base64.

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

hoặc nếu bạn muốn in một mảng các giá trị byte đã ký

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

hoặc nếu bạn muốn in một mảng các giá trị byte không dấu

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.

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

nếu bạn đang chạy 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);

đầu ra:

[7,3,5,1,3]

Trong java 8:

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

Nếu sử dụng thư viện Commons.Lang , chúng tôi có thể làm:

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

Đầu ra:

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

// Nếu bạn in địa chỉ của phần tử mảng trên bàn điều khiển trong java.

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

Có một số cách để in một phần tử mảng. Trước hết, tôi sẽ giải thích rằng, mảng là gì? .. Mảng là một cấu trúc dữ liệu đơn giản để lưu trữ dữ liệu..Khi bạn xác định một mảng, Tập hợp các khối bộ nhớ phụ trợ trong RAM. Các khối bộ nhớ được lấy một đơn vị ..

Ok, tôi sẽ tạo một mảng như thế này,

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

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

           System.out.print(number);
      }
}

Bây giờ hãy nhìn vào đầu ra,

Bạn có thể thấy một chuỗi không xác định được in..Như tôi đã đề cập trước đó, địa chỉ bộ nhớ có mảng (mảng số) được khai báo được in. Nếu bạn muốn hiển thị các phần tử trong mảng, bạn có thể sử dụng "for loop", như thế này ..

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

Bây giờ hãy nhìn vào đầu ra,

Ok, đã in thành công các phần tử của mảng một chiều..Bây giờ tôi sẽ xem xét mảng hai chiều..Tôi sẽ khai báo mảng hai chiều là "number2" và in các phần tử bằng từ khóa "Arrays.deepToString ()". Bạn sẽ phải nhập thư viện '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));
      }
}

xem xét đầu ra,

Đồng thời, Sử dụng hai cho các vòng lặp, các yếu tố 2D có thể được in..Cảm ơn bạn!