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

https://stackoverflow.com/questions/409784

03-07-2019
|

Domanda

In Java, le matrici non sovrascrivono toString(), quindi se si tenta di stamparne una direttamente, si ottiene il className + @ + l'esagono di hashCode dell'array, 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 a [1, 2, 3, 4, 5]. Qual è il modo più semplice per farlo? Ecco alcuni esempi di input e 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]

Soluzione

Dal momento che 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() su ciascun oggetto dell'array. L'output è persino decorato esattamente nel modo in cui lo chiedi.

Esempi:

Array semplice:

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

Output:

[John, Mary, Bob]

Array nidificato:

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

Output:

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

`double` Matrice:

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

Output:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

`int` Matrice:

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

Output:

[7, 9, 5, 1, 3 ]

Altri suggerimenti

Controlla sempre prima le librerie standard. Prova:

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

o se l'array contiene altri array come elementi:

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

È bello sapere, comunque, come per " 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 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
*/

Se stai usando Java 1.4, puoi invece fare:

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

(Funziona anche in 1.5+, ovviamente.)

A partire da Java 8, si potrebbe anche trarre vantaggio dal metodo join() fornito da Classe stringa per stampare elementi dell'array, senza parentesi, e separati da un delimitatore di scelta (che è lo spazio carattere per l'esempio mostrato di seguito):

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

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

Arrays.toString

Come risposta diretta, la soluzione fornita da diversi, tra cui @Esko , utilizzando Arrays.toString e Arrays.deepToString , è semplicemente il 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 di Stream.collect , usando un < code> entrare in Collector , per imitare ciò che sta facendo String.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 un array monodimensionale e Arrays.deepToString (array) per array multidimensionali.

Java 8

Ora abbiamo l'opzione Stream e lambda per stampare 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 un array multidimensionale, 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 di 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 metodo Arrays.deepToString (arr) dovrebbe prendere una stringa di separazione, ma sfortunatamente no.

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

Diversi modi di stampare array in Java:

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

Output: [Uno, Due, Tre, Quattro]

Uso di toString()

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

Output: [Uno, Due, Tre, Quattro]

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: Accesso Una matrice

L'uso del normale ciclo per è il modo più semplice di stampare array secondo me. 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 recentemente. Non è molto conveniente scrivere Arrays.toString (arr); , quindi importare java.util.Arrays; sempre.

Nota, 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 Object come tipo parent. Quindi, perché non hackerare Object.toString () ? Senza modifiche, la classe Object si presenta così:

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

Che 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 modificata può essere semplicemente aggiunta al percorso della classe aggiungendo quanto segue alla riga di comando: -Xbootclasspath / p: target / classes .

Ora, con la disponibilità di deepToString (..) da Java 5, toString (..) può essere facilmente modificato in deepToString (.. ) per aggiungere il 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 come un System.out o un PrintWriter per tali eventualità.

Dovrebbe funzionare sempre qualunque versione JDK usi:

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

Funzionerà se Array contiene oggetti. Se Array contiene 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};

Aggiornamento:

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

Quindi, solo a scopo di stampa, non dovrebbe essere usato. possiamo creare una funzione che accetta 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

stream: Arrays.stream(intArray).forEach

riferimento al metodo: ::println

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

Se vuoi stampare tutti gli elementi dell'array sulla stessa riga, usa semplicemente print invece di println cioè

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.

Uso di Jackson:

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

Uso di Gson:

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

Un collegamento semplificato che ho provato è questo:

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

Stampa

1
2
3

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

È possibile eseguire il loop nell'array, stampando ogni elemento mentre si esegue il loop. Ad esempio:

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

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

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>

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

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

Puoi 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 non firmati

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]

In java 8:

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

Esistono diversi modi per stampare gli elementi di un array. Prima di tutto, ti spiego che cos'è un array? .. L'array è una struttura di dati semplice per l'archiviazione dei dati .. Quando si definisce un array, Allocate set of blocchi di memoria ausiliari nella RAM. Questi 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 detto prima, viene stampato l'indirizzo di memoria il cui array dichiarato (array numerico). Se vuoi visualizzare elementi nell'array, puoi usare " per 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 ... Ora prenderò in considerazione un array di due dimensioni ... Dichiarerò un array di due dimensioni come "numero2". e stampa gli elementi usando " Arrays.deepToString () " parola chiave Prima di utilizzarlo 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));
      }
}

considera l'output,

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

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

uscita:

[7,3,5,1,3]

Se si utilizza Biblioteca Commons.Lang , si potrebbe fare:

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

Output:

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

Se si desidera stampare, valutare il contenuto dell'array in questo modo è possibile utilizzare Arrays.toString

jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }

jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"

jshell>

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

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

Array semplice:

Array nidificato:

double Matrice:

int Matrice:

Arrays.toString

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

Prima di Java 8

Java 8

`double` Matrice:

`int` Matrice: