Qual è il modo più semplice per stampare un array Java?

In Java, le matrici non sovrascrivono toString(), quindi se si tenta di stamparne una direttamente, si ottiene className+ '@' + l'esagono della hashCodematrice, come definito da Object.toString():

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

Ma di solito, vorremmo davvero qualcosa di più simile [1, 2, 3, 4, 5]. Qual è il modo più semplice per farlo? Ecco alcuni esempi di ingressi e uscite:

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

Da Java 5 è possibile utilizzare Arrays.toString(arr)o Arrays.deepToString(arr)per array all'interno di array. Si noti che la Object[]versione chiama .toString()ogni oggetto nell'array. L'output è persino decorato nel modo esatto in cui lo chiedi.

Esempi:

• Matrice semplice:

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

  Produzione:

  [John, Mary, Bob]

• Matrice annidata:

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

  Produzione:

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

• double Vettore:

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

  Produzione:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Vettore:

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

  Produzione:

  [7, 9, 5, 1, 3 ]

Controlla sempre prima le librerie standard.

import java.util.Arrays;

Quindi prova:

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

o se l'array contiene altri array come elementi:

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

Questo è bello da sapere, tuttavia, per quanto riguarda "controlla sempre prima le librerie standard" non mi sarei mai imbattuto nel trucco di Arrays.toString( myarray )

- dal momento che mi stavo concentrando sul tipo di myarray per vedere come farlo. Non volevo dover passare in rassegna la cosa: volevo una semplice chiamata per farlo uscire simile a quello che vedo nel debugger di Eclipse e myarray.toString () non lo facevo.

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

In JDK1.8 è possibile utilizzare le operazioni di aggregazione e un'espressione 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
*/

A partire da Java 8, si potrebbe anche trarre vantaggio dal join()metodo fornito dalla classe String per stampare elementi di array, senza parentesi e separati da un delimitatore di scelta (che è il carattere spaziale dell'esempio mostrato di seguito):

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

L'output sarà "Hey there amigo!".

Se stai usando Java 1.4, puoi invece fare:

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

(Funziona anche in 1.5+, ovviamente.)

Arrays.toString

Come risposta diretta, la soluzione fornita da molti, incluso @Esko , usando i metodi Arrays.toStringe Arrays.deepToString, è semplicemente la migliore.

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

Di seguito provo ad elencare alcuni degli altri metodi suggeriti, tentando di migliorare un po ', con l'aggiunta più notevole è l'uso Stream.collectdell'operatore, usando a , per imitare ciò che sta facendo.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);

Prima di Java 8

Avremmo potuto usare Arrays.toString(array)per stampare array monodimensionali e Arrays.deepToString(array)per array multidimensionali.

Java 8

Ora abbiamo l'opzione di Streame lambdastampare l'array.

Stampa di array monodimensionali:

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

L'output è:

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

Stampa di array multidimensionali Nel caso in cui desideriamo stampare array multidimensionali che possiamo usare Arrays.deepToString(array)come:

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

Ora il punto da osservare è che il metodo Arrays.stream(T[]), che in caso int[]ci restituisce Stream<int[]>e quindi il metodo flatMapToInt()mappa ogni elemento del flusso con il contenuto di un flusso mappato prodotto applicando la funzione di mappatura fornita a ciascun elemento.

L'output è:

[[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) stampa solo su una riga.

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

Per ottenere effettivamente una tabella da stampare come una tabella bidimensionale, ho dovuto fare questo:

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

Sembra che il Arrays.deepToString(arr)metodo dovrebbe prendere una stringa di separazione, ma sfortunatamente no.

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

Diversi modi per stampare array in Java:

1. Modo semplice

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

Uscita: [Uno, Due, Tre, Quattro]

2. utilizzando toString()

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

Uscita: [Uno, Due, Tre, Quattro]

3. Stampa di array di array

   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] [[Quinto, sesto], [settimo, ottavo]]]

Risorsa: accedere a una matrice

A mio avviso, usare il normale ciclo per è il modo più semplice di stampare array. Qui hai un codice di esempio basato sul tuo intArray

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

Fornisce output come il tuo 1, 2, 3, 4, 5

Mi sono imbattuto in questo post in Vanilla #Java di recente. Non è molto conveniente scrivere Arrays.toString(arr);, quindi importare java.util.Arrays;tutto il tempo.

Si noti che questa non è una soluzione permanente in alcun modo. Solo un trucco che può semplificare il debug.

La stampa di un array fornisce direttamente la rappresentazione interna e l'hashCode. Ora, tutte le classi hanno Objectcome tipo parent. Quindi, perché non hackerare il Object.toString()? Senza modifiche, la classe Object si presenta così:

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

Cosa succede se questo viene modificato in:

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

Questa classe Modded può semplicemente essere aggiunto al percorso di classe aggiungendo la seguente alla riga di comando: -Xbootclasspath/p:target/classes.

Ora, con la disponibilità di deepToString(..)Java 5, è toString(..)possibile modificarlo facilmente deepToString(..)per aggiungere supporto per array che contengono altri array.

Ho trovato questo un trucco abbastanza utile e sarebbe fantastico se Java potesse semplicemente aggiungere questo. Comprendo potenziali problemi con array molto grandi poiché le rappresentazioni delle stringhe potrebbero essere problematiche. Forse passare qualcosa del tipo a System.outo a PrintWriterper tali eventualità.

Dovrebbe funzionare sempre qualunque versione JDK usi:

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

Funzionerà se Arraycontiene oggetti. Se Arraycontiene tipi di primitive, è possibile utilizzare le classi wrapper invece di archiviare la primitiva direttamente come ..

Esempio:

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

Sostituiscilo con:

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

Aggiornare :

Sì ! questo è da ricordare che la conversione di un array in un array di oggetti O per utilizzare l'array dell'Oggetto è costoso e può rallentare l'esecuzione. succede per natura di java chiamato autoboxing.

Quindi solo a scopo di stampa, non dovrebbe essere usato. possiamo fare una funzione che prende un array come parametro e stampa il formato desiderato come

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

In java 8 è facile. ci sono due parole chiave

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

2. metodo di riferimento: ::println

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

Se si desidera stampare tutti gli elementi dell'array nella stessa riga, utilizzare semplicemente printanziché printlnie

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

Un altro modo senza riferimento al metodo basta usare:

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

C'è un altro modo se il tuo array è di tipo char []:

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

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

stampe

abc

Per aggiungere a tutte le risposte, è anche possibile stampare l'oggetto come una stringa JSON.

Utilizzando Jackson:

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

Utilizzando Gson:

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

È possibile eseguire il ciclo attraverso l'array, stampando ogni elemento mentre si esegue il ciclo. Per esempio:

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

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

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

}

Produzione:

item 1
item 2
item 3

Esistono i seguenti modi per stampare l'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);
     }

Un collegamento semplificato che ho provato è questo:

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

Stamperà

1
2
3

Non sono richiesti loop in questo approccio ed è consigliabile solo per array di piccole dimensioni

Per ogni ciclo può anche essere usato per stampare elementi dell'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);
        }
      }
    }

L'uso dei metodi org.apache.commons.lang3.StringUtils.join (*) può essere un'opzione
Ad esempio:

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

Ho usato la seguente dipendenza

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

Questo è contrassegnato come duplicato per la stampa di un byte [] . Nota: per un array di byte ci sono metodi aggiuntivi che potrebbero essere appropriati.

È possibile stamparlo come stringa se contiene caratteri ISO-8859-1.

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

o se contiene una stringa UTF-8

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

o se vuoi stamparlo come esadecimale.

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

o se vuoi stamparlo come base64.

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

o se si desidera stampare un array di valori di byte con segno

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

o se si desidera stampare un array di valori byte senza segno

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]

se stai eseguendo 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);

produzione:

[7,3,5,1,3]

In java 8:

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

Se si utilizza la libreria Commons.Lang , è possibile:

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

Produzione:

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

// Se si stampa l'indirizzo dell'elemento array sulla console in Java.

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

Esistono diversi modi per stampare elementi di un array. Innanzitutto, lo spiegherò, cos'è un array? .. L'array è una struttura di dati semplice per l'archiviazione dei dati ... Quando si definisce un array, allocare un insieme di blocchi di memoria ausiliari nella RAM. I blocchi di memoria sono presi in un'unità.

Ok, creerò un array come questo,

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

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

           System.out.print(number);
      }
}

Ora guarda l'output,

Puoi vedere una stringa sconosciuta stampata ... Come ho già detto, viene stampato l'indirizzo di memoria il cui array (array numerico) dichiarato. Se vuoi visualizzare elementi nell'array, puoi usare "for loop", come questo ...

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

Ora guarda l'output,

Ok, elementi stampati con successo di un array di dimensioni ... Adesso prenderò in considerazione un array di due dimensioni ... Dichiarerò un array di due dimensioni come "numero2" e stamperò gli elementi usando la parola chiave "Arrays.deepToString ()". Prima di usarlo Dovrai importare la libreria '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));
      }
}

considerare l'output,

Allo stesso tempo, utilizzando due per i loop, è possibile stampare elementi 2D ... Grazie!