Ce's cel mai simplu mod de a imprima un Java array?

Deoarece Java 5 puteți utiliza Tablouri.toString(arr) sau Tablouri.deepToString(arr) pentru tablouri în matrice. Rețineți că Object [] versiunea pentru telefoane.toString (), pe fiecare obiect în matrice. Ieșirea este decorat în aceeași manieră ai're cer.

Exemple:

• Simplu Matrice:

String[] tablou = new String[] {"John", "Maria", "Bob"}; Sistem.afară.println(Arrays.toString(array));

Ieșire:

[Ioan, Maria, Bob]

• Imbricate Matrice:

String[][] deepArray = new String[][] {{"John", "Maria"}, {"Alice", "Bob"}}; Sistem.afară.println(Arrays.toString(deepArray)); //ieșire: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922] Sistem.afară.println(Arrays.deepToString(deepArray));

Ieșire:

[[Ioan, Maria], [Alice, Bob]]

• "dublu" Matrice:

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

Ieșire:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Matrice:

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

Ieșire:

[7, 9, 5, 1, 3 ]

Verificați întotdeauna standard de biblioteci în primul rând. Încercați:

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

sau daca array-ul conține și alte rețele și elemente:

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

Acest lucru este frumos să știu, cu toate acestea, ca și pentru "verificați întotdeauna standard biblioteci primul" I'd nu au dat peste un truc de Tablouri.toString( myarray )`

• când am fost concentrându-se pe tipul de myarray pentru a vedea cum pentru a face acest lucru. Am't vreau să aibă de a repeta prin lucru: am vrut un telefon simplu pentru a face iasă similar cu ceea ce văd în Eclipse debugger și myarray.toString() era't o face.

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

În JDK1.8 puteți utiliza agregate de operațiuni și o expresie 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
*/

Daca're folosind Java 1.4, poți în schimb să faci:

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

(Aceasta funcționează în 1,5+ prea, desigur.)

Incepand cu Java 8, s-ar putea, de asemenea, profita de join()` metoda furnizate de clasa String pentru a imprima elementele de matrice, fără paranteze și separate printr-un delimitator de alegere (care este caracterul spațiu pentru exemplul prezentat mai jos):

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

Producția va fi "Hei, prietene!".

Tablouri.toString

Ca un răspuns direct, soluția oferită de mai multe, inclusiv @Esko, folosind Arrays.toString și Arrays.deepToString metode, este pur și simplu cel mai bun.

Java 8 - Stream.colecta(aderarea()), Flux.forEach

Mai jos voi încerca să lista unele dintre alte metode sugerate, încercarea de a îmbunătăți un pic, cu cele mai notabile plus fiind utilizarea Stream.collect operatorul, folosind un joining "Colector", pentru a imita ceea ce `Șir de caractere.alătură-te este de a face.

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

Înainte de Java 8

Ne-ar fi folosit Tablouri.toString(matrice) pentru a imprima o matrice dimensionale și Tablouri.deepToString(matrice) pentru matrice multi-dimensionale.

Java 8

Acum avem optiunea de "Stream" și "lambda" pentru a imprima matrice.

Imprimarea Unul dimensional Matrice:

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

De ieșire este:

[1, 2, 3, 4, 5] [Ioan, Maria, Bob] Unul Două Trei Patru Cinci John Mary Bob

Imprimarea Multi-dimensional Matrice În caz că doriți să imprimați multi-dimensional matrice putem folosi Tablouri.deepToString(matrice)` ca:

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

Acum pe punctul de a observa este că metoda Tablouri.stream(T[]), care, în caz de int[] ne întoarce Flux<int[]> și apoi metodaflatMapToInt()` maps fiecare element de flux cu conținutul unui mapate fluxul produs prin aplicarea prevăzută funcția de cartografiere pentru fiecare element.

De ieșire este:

[[11, 12], [21, 22], [31, 32, 33]] [[Ioan, Bravo], [Mary, Lee], [Bob, Johnson]] Unsprezece Doisprezece Douăzeci și una de Douăzeci și doi de Treizeci și unu Treizeci și două de Treizeci și trei de John Bravo Mary Lee Bob Johnson

Tablouri.deepToString(arr) tipărește numai pe o singură linie.

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

Pentru a obține de fapt, un tabel pentru a imprima ca un bidimensională masă, am avut de a face acest lucru:

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

Se pare ca Tablouri.deepToString(arr) metoda ar trebui să ia un separator șir, dar, din păcate, nu't.

Diferite Moduri de a Imprima Tablouri în Java:

1. Mod Simplu

Listă list = new ArrayList(); lista.adauga("O"); lista.adauga("Doi"); lista.adauga("de Trei"); lista.adauga("Patru"); // Imprima lista in consola Sistem.afară.println(lista);

Ieșire: [Unu, Doi, Trei, Patru]

2. Folosind toString()

String[] tablou = new String[] { "O", "Doi", "Trei", "Patru" }; Sistem.afară.println(Arrays.toString(array));

Ieșire: [Unu, Doi, Trei, Patru]

3. Imprimare Serie de Tablouri

String[] arr1 = new String[] { "al Cincilea", "al Șaselea" }; String[] arr2 = new String[] { "al Șaptelea", "Opt" }; String[][] arrayOfArray = new String[][] { arr1, arr2 }; Sistem.afară.println(arrayOfArray); Sistem.afară.println(Arrays.toString(arrayOfArray)); Sistem.afară.println(Arrays.deepToString(arrayOfArray));

Ieșire: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[a Cincea, a Șasea], [al Șaptelea, al Optulea]]

Resurse: Accesa O Serie

Folosind regulat pentru bucla este cel mai simplu mod de imprimare matrice în opinia mea. Aici ai un exemplu de cod bazat pe intArray

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

Acesta oferă ieșire ca a ta 1, 2, 3, 4, 5

În java 8 este ușor. există două cuvinte cheie

1. flux: Tablouri.stream(intArray).forEach
2. metodă de referință: ::println

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

Dacă doriți să imprimați toate elementele din matrice în aceeași linie, apoi utilizați doar print "în loc de" println adică

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

Un alt mod fără metodă de referință folosi doar:

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

Acesta ar trebui să lucreze întotdeauna indiferent de versiunea JDK utilizați:

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

Acesta va funcționa dacă "Matrice" conține Obiecte. Dacă "Matrice" conține tipuri primitive, puteți utiliza clase wrapper în loc stocarea primitive direct ca..

Exemplu:

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

Înlocuiți-l cu:

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

Actualizare :

Da ! acest lucru este de a fi menționat că transformarea unei matrice la un obiect array SAU de a folosi Obiectul's matrice este costisitoare și mai lent de execuție. se întâmplă de natura java numit autoboxing.

Deci numai pentru imprimare scop, Aceasta nu ar trebui să fie utilizate. putem face o funcție care ia ca parametru o matrice și printuri de format dorit ca

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

Am dat peste acest post în Vanilie #Java recent. L's nu foarte convenabil scris Tablouri.toString(arr);, apoi importând `java.util.Tablouri; tot timpul.

Vă rugăm să rețineți, acest lucru nu este o soluție permanentă, prin orice mijloace. Doar un hack care poate face debugging mai simplu.

Imprimarea unei matrice direct oferă reprezentare internă și hashCode. Acum, toate clasele au "Obiect" ca părinte-tip. Deci, de ce nu hack Obiect.toString()? Fără modificări, la clasa Object arată astfel:

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

Ce se întâmplă dacă acest lucru este schimbat la:

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

Acest modded clasa poate fi pur și simplu adăugate la clasa calea prin adăugarea următoarelor pentru a linia de comandă: -Xbootclasspath/p:țintă/clase.

Acum, cu disponibilitatea de deepToString(..) deoarece Java 5, toString(..) poate fi ușor schimbat la deepToString(..) pentru a adăuga suport pentru matrice care conțin alte tablouri.

Am găsit acest lucru să fie o destul de util hack și ar fi minunat dacă Java ar putea pur și simplu adăugați acest lucru. Înțeleg potențialele probleme cu care are foarte mari tablouri din șirul reprezentărilor ar putea fi problematică. Poate trece ceva ca un Sistem.afară ' or a PrintWriter pentru o astfel de eventualitate.

Nu's o modalitate suplimentară dacă matricea este de tip char[]:

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

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

printuri

abc

Ai putea bucla prin matrice, imprimarea fiecare element, ca ai buclă. De exemplu:

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

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

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

}

Ieșire:

item 1
item 2
item 3

Pentru a adăuga la toate răspunsurile, imprimare obiectul ca un șir JSON este, de asemenea, o opțiune.

Folosind Jackson:

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

Folosind Gson:

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

Există Următoarele pentru a imprima Matrice

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

Pentru fiecare buclă poate fi, de asemenea, folosit pentru a imprima elementele de matrice:

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