java - sort - print array python




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

In Java, gli array non sovrascrivono toString() , quindi se provate a stamparne uno direttamente, ottenete className + @ + l'esadecimale del hashCode dell'array, come definito da Object.toString() :

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

Ma di solito vorremmo qualcosa di più come [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]

Arrays.toString

Come risposta diretta, la soluzione fornita da diversi, incluso @Esko , che utilizza i metodi Arrays.toString e Arrays.deepToString , è semplicemente la migliore.

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

Di seguito provo ad elencare alcuni degli altri metodi suggeriti, tentando di migliorare un po ', con l'aggiunta più notevole essendo l'uso dell'operatore Stream.collect , utilizzando un Collector di String.join , 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);

È bello sapere, comunque, che per "controllare sempre prima le librerie standard" non mi sarei mai imbattuto nel trucco di Arrays.toString( myarray )

- perché mi stavo concentrando sul tipo di myarray per vedere come farlo. Non volevo dover scorrere la cosa: volevo una semplice chiamata per farlo uscire simile a quello che vedo nel debugger di Eclipse e myarray.toString () non lo stava facendo.

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

A partire da Java 8, si potrebbe anche sfruttare il metodo join() fornito dalla classe String per stampare gli elementi dell'array, senza parentesi, e separati da un delimitatore di scelta (che è il carattere dello spazio per l'esempio mostrato sotto) :

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

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


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

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

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

stampe

abc

Da Java 5 è possibile utilizzare Arrays.toString(arr) per array semplici o Arrays.deepToString(arr) per array annidati. Si noti che la versione Object[] chiama .toString() su ogni oggetto dell'array. L'output è persino decorato nel modo esatto che stai chiedendo.

Esempi:

Array semplice:

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

Produzione:

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

Produzione:

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

double matrice:

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 array:

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

Produzione:

[7, 9, 5, 1, 3 ]

Dovrebbe funzionare sempre con qualsiasi versione di JDK utilizzata:

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

Funzionerà se la Array contiene oggetti. Se la Array contiene tipi primitivi, puoi usare le classi wrapper invece di memorizzare la primitiva direttamente come ..

Esempio:

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

Sostituirlo con:

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

Aggiornare :

Sì ! questo vuol dire che la conversione di una matrice in una matrice di oggetti OR per utilizzare la matrice dell'oggetto è costosa e può rallentare l'esecuzione. succede per la natura di java chiamata autoboxing.

Quindi, solo per scopi 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
} 

Il modo più semplice per stampare un array è utilizzare un ciclo for:

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

In JDK1.8 puoi 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
*/

In Java 8:

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

L'utilizzo dei metodi org.apache.commons.lang3.StringUtils.join (*) può essere un'opzione
Per 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 aggiungere a tutte le risposte, anche la stampa dell'oggetto come stringa JSON è un'opzione.

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

Per ogni ciclo può essere utilizzato anche per stampare elementi di array:

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

Prima di Java 8 avremmo potuto usare Arrays.toString(array) per stampare array monodimensionali e Arrays.deepToString(array) per array multidimensionali. Abbiamo l'opzione Stream e lambda in Java 8 che può essere utilizzata anche per la stampa dell'array.

Stampa di una matrice monodimensionale:

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
Maria
peso

Stampa di array multidimensionale Nel caso in cui si desideri stampare array multidimensionali, è possibile utilizzare 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 mapping flusso 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
Maria
sottovento
peso
Johnson


Questo è contrassegnato come duplicato per la stampa di un byte [] . Nota: per un array di byte ci sono metodi aggiuntivi che possono 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 una matrice 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 una matrice di valori di 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.

Se stai usando Java 1.4, puoi invece fare:

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

(Questo funziona anche in 1.5+, ovviamente.)


Una scorciatoia semplificata che ho provato è questa:

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

Stamperà

1
2
3

Nessun loop richiesto in questo approccio ed è meglio solo per i piccoli array


Arrays.deepToString(arr) stampa solo su una riga.

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

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

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

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


Ci sono i seguenti modi per stampare 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);
     }

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

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






printing