Apa's cara yang paling sederhana untuk mencetak Java array?

Sejak Jawa 5 anda dapat menggunakan Array.toString(arr) atau Array.deepToString(arr) untuk array dalam array. Perhatikan bahwa Object [] versi panggilan .toString() pada masing-masing objek di dalam array. Output bahkan dihiasi dengan cara yang tepat anda'kembali bertanya.

Contoh:

• Sederhana Array:

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

Output:

[Yohanes, Maria, Bob]

• Bersarang Array:

String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}}; Sistem.keluar.println(Arrays.toString(deepArray)); //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922] Sistem.keluar.println(Arrays.deepToString(deepArray));

Output:

[[Yohanes, Maria], [Alice, Bob]]

• double Array:

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

Output:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Array:

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

Output:

[7, 9, 5, 1, 3 ]

Selalu memeriksa standar perpustakaan pertama. Coba:

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

atau jika array berisi array lain sebagai unsur-unsur:

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

Ini bagus untuk mengetahui, namun, seperti untuk "selalu memeriksa standar perpustakaan pertama" aku'd pernah tersandung pada trik Array.toString( myarray )

• karena saya sedang berkonsentrasi pada jenis myarray untuk melihat bagaimana untuk melakukan hal ini. Aku't ingin memiliki untuk iterate melalui hal: saya ingin panggilan yang mudah untuk membuat keluar yang mirip dengan apa yang saya lihat di Eclipse debugger dan myarray.toString() hanya wasn't melakukan itu.

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

Di JDK1.8 anda dapat menggunakan agregat operasi dan 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
*/

Jika anda're menggunakan Java 1.4, anda malah bisa lakukan:

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

(Ini bekerja di 1.5+ juga, tentu saja.)

Dimulai dengan Java 8, salah satu juga dapat mengambil keuntungan dari join() metode yang disediakan oleh String kelas untuk mencetak elemen array tanpa tanda kurung dan dipisahkan oleh pembatas pilihan (yang merupakan karakter ruang untuk contoh yang ditunjukkan di bawah ini):

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

Output akan menjadi "Hey amigo!".

Array.toString

Sebagai jawaban langsung, solusi yang ditawarkan oleh beberapa, termasuk @Eskomenggunakan Arrays.toString dan Arrays.deepToString metode, adalah hanya yang terbaik.

Jawa 8 - Stream.mengumpulkan(bergabung()), Aliran.forEach

Di bawah ini saya mencoba untuk daftar beberapa metode lain yang disarankan, mencoba untuk meningkatkan sedikit, dengan yang paling penting selain menjadi penggunaan Stream.collect operator, menggunakan joining Kolektor, untuk meniru apa String.bergabung lakukan.

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

Sebelum ke Jawa 8

Kita bisa menggunakan Array.toString(array) untuk mencetak satu dimensi array dan Array.deepToString(array)` untuk array multi-dimensi.

Jawa 8

Sekarang kita punya pilihan Aliran dan lambda untuk mencetak array.

Mencetak Satu dimensi 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);
}

Output adalah:

[1, 2, 3, 4, 5] [Yohanes, Maria, Bob] Satu Dua Tiga Empat Lima John Mary Bob

Pencetakan Multi-dimensi Array Hanya dalam kasus kami ingin mencetak multi-dimensi array kita dapat menggunakan Array.deepToString(array) sebagai:

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

Sekarang titik untuk mengamati adalah bahwa metode Array.stream(T[]), yang dalam kasus int[] kembali kita Arus<int[]> dan kemudian metode flatMapToInt() peta masing-masing elemen dari aliran dengan isi yang dipetakan stream diproduksi dengan menerapkan disediakan pemetaan fungsi untuk masing-masing elemen.

Output adalah:

[[11, 12], [21, 22], [31, 32, 33]] [[John, Bravo], [Mary, Lee], [Bob, Johnson]] Sebelas Dua belas Dua puluh satu Dua puluh dua Tiga puluh satu Tiga puluh dua Tiga puluh tiga John Bravo Mary Lee Bob Johnson

Array.deepToString(arr) hanya mencetak pada satu baris.

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

Untuk benar-benar mendapatkan meja untuk mencetak dua dimensi meja, aku harus melakukan ini:

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

Sepertinya `Array.deepToString(arr) metode harus mengambil string pemisah, tapi sayangnya itu doesn't.

Cara yang berbeda untuk Mencetak Array dalam Java:

1. Cara Sederhana

Daftar list = new ArrayList(); daftar.tambahkan(""); daftar.tambahkan("Dua"); daftar.tambahkan("Tiga"); daftar.tambahkan("Empat"); // Cetak daftar di konsol Sistem.keluar.println(klik disini);

Output: [Satu, Dua, Tiga, Empat]

2. Menggunakan toString()

String[] array = new String[] { "", "Dua", "Tiga", "Empat" }; Sistem.keluar.println(Arrays.toString(array));

Output: [Satu, Dua, Tiga, Empat]

3. Cetak Array

String[] arr1 = new String[] { "Kelima", "Keenam" }; String[] arr2 = new String[] { "Ketujuh", "Delapan" }; String[][] arrayOfArray = new String[][] { arr1, arr2 }; Sistem.keluar.println(arrayOfArray); Sistem.keluar.println(Arrays.toString(arrayOfArray)); Sistem.keluar.println(Arrays.deepToString(arrayOfArray));

Output: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[Kelima, Keenam], [Ketujuh, Kedelapan]]

Sumber: Akses Array

Menggunakan regular untuk ** loop adalah cara paling sederhana pencetakan array dalam pendapat saya. Di sini anda memiliki kode sampel berdasarkan intArray

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

Ini memberikan output sebagai milikmu 1, 2, 3, 4, 5

Di jawa 8 sangat mudah. ada dua kata kunci

1. aliran: Array.stream(intArray).forEach
2. metode referensi: ::println

int[] intArray = new int[] {1, 2, 3, 4, 5}; Array.stream(intArray).forEach(Sistem.keluar::println);

Jika anda ingin mencetak semua elemen dalam array pada baris yang sama, maka cukup gunakan cetak bukan println yaitu

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

Cara lain tanpa referensi metode hanya menggunakan:

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

Itu harus selalu bekerja mana JDK versi yang anda gunakan:

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

Ini akan bekerja jika Array berisi benda-Benda. Jika Array berisi tipe primitif, anda dapat menggunakan wrapper classes bukan menyimpan primitif langsung seperti..

Contoh:

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

Ganti dengan:

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

Update :

Ya ! ini harus menyebutkan bahwa konversi array ke array objek ATAU untuk menggunakan Objek's hotel yang lebih mahal dan dapat memperlambat eksekusi. hal ini terjadi oleh alam jawa disebut autoboxing.

Jadi hanya untuk tujuan pencetakan, Itu tidak boleh digunakan. kita dapat membuat fungsi yang mengambil array sebagai parameter dan cetakan yang diinginkan format sebagai

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

Saya menemukan posting ini di Vanilla #Java baru-baru ini. It's sangat tidak nyaman menulis Array.toString(arr);, kemudian mengimpor jawa.util.Array; sepanjang waktu.

Harap dicatat, ini bukan permanen memperbaiki dengan cara apapun. Hanya sebuah hack yang dapat membuat debugging sederhana.

Cetak array langsung memberikan representasi internal dan kode hash. Sekarang, semua kelas memiliki Objek sebagai induk-jenis. Jadi, mengapa tidak di-hack Objek.toString()? Tanpa modifikasi, kelas Objek terlihat seperti ini:

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

Bagaimana jika ini diubah menjadi:

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

Ini modded kelas mungkin hanya akan ditambahkan ke kelas jalan dengan menambahkan baris berikut ke baris perintah: -Xbootclasspath/p:sasaran/kelas.

Sekarang, dengan ketersediaan deepToString(..) sejak Java 5, toString(..) dapat dengan mudah diubah menjadi deepToString(..) untuk menambahkan dukungan untuk array yang berisi array lain.

Saya menemukan ini menjadi sangat berguna hack dan itu akan menjadi besar jika Java hanya bisa tambahkan ini. Saya memahami potensi masalah dengan memiliki array yang sangat besar sejak string pernyataan bisa menjadi bermasalah. Mungkin lulus sesuatu seperti Sistem.keluar d'or yangPrintWriter` untuk meminimalisir resiko tersebut.

Ada's salah satu cara tambahan jika anda array dengan tipe char[]:

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

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

cetakan

abc

Anda bisa loop melalui array, mencetak masing-masing item, seperti yang anda loop. Misalnya:

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

Untuk menambah semua jawaban, percetakan objek sebagai string JSON adalah juga sebuah pilihan.

Menggunakan Jackson:

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

Menggunakan Gson:

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

Ada cara Berikut untuk mencetak 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);
     }

Untuk setiap loop juga dapat digunakan untuk mencetak elemen array:

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