Apa cara paling sederhana untuk mencetak array Java?

Di Java, array tidak menimpa toString(), jadi jika Anda mencoba untuk mencetaknya secara langsung, Anda mendapatkan className+ '@' + hex dari hashCodearray, seperti yang didefinisikan oleh Object.toString():

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

Tapi biasanya, kami sebenarnya menginginkan sesuatu yang lebih seperti [1, 2, 3, 4, 5]. Apa cara paling sederhana untuk melakukan itu? Berikut 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]

Karena Java 5 Anda dapat menggunakan Arrays.toString(arr)atau Arrays.deepToString(arr)untuk array dalam array. Perhatikan bahwa Object[]versi ini memanggil .toString()setiap objek dalam array. Outputnya bahkan didekorasi persis seperti yang Anda tanyakan.

Contoh:

• Array sederhana:

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

  Keluaran:

  [John, Mary, Bob]

• Array bersarang:

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

  Keluaran:

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

• double Himpunan:

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

  Keluaran:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Himpunan:

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

  Keluaran:

  [7, 9, 5, 1, 3 ]

Selalu periksa perpustakaan standar terlebih dahulu.

import java.util.Arrays;

Lalu coba:

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

atau jika array Anda mengandung array lain sebagai elemen:

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

Ini bagus untuk diketahui, karena, karena "selalu memeriksa perpustakaan standar dulu" saya tidak akan pernah menemukan trik Arrays.toString( myarray )

--Karena saya berkonsentrasi pada jenis myarray untuk melihat bagaimana melakukan ini. Saya tidak ingin harus mengulangi hal itu: Saya ingin panggilan mudah untuk membuatnya keluar mirip dengan apa yang saya lihat di debugger Eclipse dan myarray.toString () hanya tidak melakukannya.

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

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

Dimulai dengan Java 8, kita juga bisa memanfaatkan join()metode yang disediakan oleh kelas String untuk mencetak elemen array, tanpa tanda kurung, dan dipisahkan oleh pembatas pilihan (yang merupakan karakter spasi untuk contoh yang ditunjukkan di bawah):

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

Outputnya adalah "Hei, ada amigo!".

Jika Anda menggunakan Java 1.4, Anda bisa melakukan:

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

(Ini bekerja di 1,5+ juga, tentu saja.)

Arrays.toString

Sebagai jawaban langsung, solusi yang disediakan oleh beberapa, termasuk @Esko , menggunakan Arrays.toStringdan Arrays.deepToStringmetode, adalah yang terbaik.

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

Di bawah ini saya mencoba untuk membuat daftar beberapa metode lain yang disarankan, berusaha sedikit meningkatkan, dengan tambahan yang paling terkenal adalah penggunaan Stream.collectoperator, menggunakan a , untuk meniru apa yang sedang dilakukan.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);

Sebelum ke Jawa 8

Kita bisa digunakan Arrays.toString(array)untuk mencetak array satu dimensi dan Arrays.deepToString(array)untuk array multi dimensi.

Java 8

Sekarang kita sudah mendapat opsi Streamdan lambdauntuk mencetak array.

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

Outputnya adalah:

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

Mencetak Array Multi-Dimensi Jika kita ingin mencetak array multi-dimensi dapat kita gunakan Arrays.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 yang perlu diperhatikan adalah metode tersebut Arrays.stream(T[]), yang dalam kasus int[]mengembalikan kita Stream<int[]>dan kemudian metode flatMapToInt()memetakan setiap elemen aliran dengan isi aliran yang dipetakan yang dihasilkan dengan menerapkan fungsi pemetaan yang disediakan untuk setiap elemen.

Outputnya adalah:

[[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) hanya mencetak pada satu baris.

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

Untuk benar-benar mendapatkan tabel untuk dicetak sebagai tabel dua dimensi, saya harus melakukan ini:

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

Sepertinya Arrays.deepToString(arr)metode ini harus mengambil string pemisah, tetapi sayangnya tidak.

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

Berbagai Cara untuk Mencetak Array di Jawa:

1. Cara Sederhana

   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: [Satu, Dua, Tiga, Empat]

2. Menggunakan toString()

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

Output: [Satu, Dua, Tiga, Empat]

3. Mencetak 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] [[Kelima, Keenam], [Ketujuh, Kedelapan]]

Sumber: Mengakses Array

Menggunakan regular for loop adalah cara paling sederhana untuk mencetak array menurut saya. Di sini Anda memiliki kode sampel berdasarkan intArray Anda

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

Ini memberikan output sebagai milik Anda 1, 2, 3, 4, 5

Saya menemukan posting ini di Vanilla #Java baru-baru ini. Menulisnya tidak nyaman Arrays.toString(arr);, lalu mengimpor java.util.Arrays;sepanjang waktu.

Harap dicatat, ini bukan perbaikan permanen dengan cara apa pun. Hanya sebuah retasan yang dapat membuat proses debug menjadi lebih sederhana.

Mencetak array secara langsung memberikan representasi internal dan kode hash. Sekarang, semua kelas memiliki Objecttipe induk. Jadi, mengapa tidak meretasnya Object.toString()? Tanpa modifikasi, kelas Object 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());
}

Kelas modded ini mungkin hanya ditambahkan ke jalur kelas dengan menambahkan berikut ke baris perintah: -Xbootclasspath/p:target/classes.

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

Saya menemukan ini sebagai hack yang cukup berguna dan akan lebih bagus jika Java bisa menambahkan ini. Saya mengerti masalah potensial dengan memiliki array yang sangat besar karena representasi string bisa bermasalah. Mungkin melewati sesuatu seperti a System.outatau a PrintWriteruntuk kemungkinan seperti itu.

Itu harus selalu berfungsi versi JDK mana pun yang Anda gunakan:

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

Ini akan berfungsi jika Arraymengandung Objects. Jika Arrayberisi tipe primitif, Anda bisa menggunakan kelas wrapper alih-alih menyimpan primitif secara langsung sebagai ..

Contoh:

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

Ganti dengan:

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

Perbarui:

Iya ! ini harus disebutkan bahwa mengubah array ke array objek ATAU menggunakan array Obyek mahal dan dapat memperlambat eksekusi. itu terjadi oleh sifat java yang disebut autoboxing.

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

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

Di java 8 itu mudah. ada dua kata kunci

1. aliran: Arrays.stream(intArray).forEach

2. referensi metode: ::println

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

Jika Anda ingin mencetak semua elemen dalam array dalam baris yang sama, maka cukup gunakan printbukan printlnyaitu

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

Cara lain tanpa referensi metode cukup gunakan:

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

Ada satu cara tambahan jika array Anda bertipe char []:

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

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

cetakan

abc

Untuk menambahkan semua jawaban, mencetak objek sebagai string JSON juga merupakan opsi.

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

Anda dapat mengulang melalui array, mencetak setiap item, saat Anda mengulang. Sebagai contoh:

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

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

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

}

Keluaran:

item 1
item 2
item 3

Ada Cara Mengikuti 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);
     }

Pintasan sederhana yang saya coba adalah ini:

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

Itu akan mencetak

1
2
3

Tidak diperlukan loop dalam pendekatan ini dan yang terbaik untuk array kecil saja

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

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

Menggunakan metode org.apache.commons.lang3.StringUtils.join (*) dapat menjadi pilihan
Misalnya:

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

Saya menggunakan dependensi berikut

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

Ini ditandai sebagai duplikat untuk mencetak byte [] . Catatan: untuk array byte ada metode tambahan yang mungkin sesuai.

Anda dapat mencetaknya sebagai String jika berisi karakter ISO-8859-1.

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

atau jika mengandung string UTF-8

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

atau jika Anda ingin mencetaknya sebagai heksadesimal.

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

atau jika Anda ingin mencetaknya sebagai base64.

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

atau jika Anda ingin mencetak array nilai byte yang ditandatangani

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

atau jika Anda ingin mencetak array nilai byte yang tidak ditandatangani

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]

jika Anda menjalankan 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);

keluaran:

[7,3,5,1,3]

Di java 8:

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

Jika menggunakan perpustakaan Commons.Lang , kita bisa melakukan:

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

Keluaran:

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

// Jika Anda mencetak alamat elemen array pada konsol di java.

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

Ada beberapa cara untuk mencetak elemen array. Pertama-tama, saya akan menjelaskan bahwa, apa itu array? .. Array adalah struktur data sederhana untuk menyimpan data .. Ketika Anda mendefinisikan sebuah array, alokasikan set blok memori tambahan dalam RAM. Blok memori tersebut diambil satu unit ..

Ok, saya akan membuat array seperti ini,

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

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

           System.out.print(number);
      }
}

Sekarang lihat outputnya,

Anda dapat melihat string yang tidak dikenal dicetak .. Seperti yang saya sebutkan sebelumnya, alamat memori yang array (jumlah array) dinyatakan dicetak. Jika Anda ingin menampilkan elemen dalam array, Anda dapat menggunakan "untuk loop", seperti ini ..

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

Sekarang lihat outputnya,

Ok, elemen-elemen array satu dimensi yang berhasil dicetak .. Sekarang saya akan mempertimbangkan array dua dimensi .. Saya akan mendeklarasikan array dua dimensi sebagai "number2" dan mencetak elemen menggunakan kata kunci "Arrays.deepToString ()" .Sebelum menggunakan itu Anda harus mengimpor perpustakaan '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));
      }
}

pertimbangkan output,

Pada saat yang sama, Menggunakan dua untuk loop, elemen 2D dapat dicetak .. Terima kasih!