Di Jawa, array don't menimpa toString()
, jadi jika anda mencoba untuk mencetak satu secara langsung, anda mendapatkan className
+ '@' + hex dari kode hash
array, seperti yang didefinisikan oleh Objek.toString()
:
int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray); // prints something like '[I@3343c8b3'
Tapi biasanya, kita'd benar-benar ingin sesuatu yang lebih seperti[1, 2, 3, 4, 5]
. Apa's cara yang paling sederhana untuk melakukan itu? Berikut ini adalah beberapa contoh input dan output:
// 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]
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:
String[] array = new String[] {"John", "Mary", "Bob"}; Sistem.keluar.println(Arrays.toString(array));
Output:
[Yohanes, Maria, Bob]
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 ]
Ini bagus untuk mengetahui, namun, seperti untuk "selalu memeriksa standar perpustakaan pertama" aku'd pernah tersandung pada trik Array.toString( myarray )
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
*/
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!".
Sebagai jawaban langsung, solusi yang ditawarkan oleh beberapa, termasuk @Eskomenggunakan Arrays.toString
dan Arrays.deepToString
metode, adalah hanya yang terbaik.
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);
Kita bisa menggunakan Array.toString(array)
untuk mencetak satu dimensi array dan Array.deepToString(array)` untuk array multi-dimensi.
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:
Daftar
Output: [Satu, Dua, Tiga, Empat]
toString()
String[] array = new String[] { "", "Dua", "Tiga", "Empat" }; Sistem.keluar.println(Arrays.toString(array));
Output: [Satu, Dua, Tiga, Empat]
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
Array.stream(intArray).forEach
::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 yang
PrintWriter` untuk meminimalisir resiko tersebut.
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);
}