Pregunta ¿Cuál es la forma más sencilla de imprimir una matriz de Java?


En Java, las matrices no anulan toString(), así que si intenta imprimir uno directamente, obtendrá el nombre de clase + @ + el hexágono del hashCode de la matriz, como se define por Object.toString():

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

Pero por lo general, realmente queremos algo más como [1, 2, 3, 4, 5]. ¿Cuál es la forma más simple de hacer eso? Aquí hay algunos ejemplos de entradas y salidas:

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

1526
2018-01-03 20:39


origen


Respuestas:


Desde Java 5 puedes usar Arrays.toString(arr) o Arrays.deepToString(arr) para matrices dentro de matrices. Tenga en cuenta que Object[] llamadas de versión .toString() en cada objeto en la matriz. La salida incluso está decorada de la manera exacta en que está preguntando.

Ejemplos:

Arreglo simple:

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

Salida:

[John, Mary, Bob]

Matriz anidada:

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

Salida:

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

double Formación:

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

Salida:

[7.0, 9.0, 5.0, 1.0, 3.0 ]

int Formación:

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

Salida:

[7, 9, 5, 1, 3 ]

2035
2018-01-03 20:48



Siempre verifique primero las bibliotecas estándar. Tratar:

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

o si su matriz contiene otras matrices como elementos:

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

304
2018-05-12 21:01



Sin embargo, es bueno saber que, como "siempre verifique primero las bibliotecas estándar", nunca me habría tropezado con el truco de Arrays.toString( myarray )

Desde que me estaba concentrando en el tipo de myarray para ver cómo hacer esto. No quería tener que repetir el asunto: quería una llamada fácil para que salga de manera similar a lo que veo en el depurador de Eclipse y myarray.toString () simplemente no lo estaba haciendo.

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

85
2018-02-06 23:35



En JDK1.8 puede usar operaciones agregadas y una expresión 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
*/

70
2018-01-03 21:44



Si está utilizando Java 1.4, puede hacer lo siguiente:

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

(Esto también funciona en 1.5+, por supuesto).


37
2017-12-23 18:51



Comenzando con Java 8, uno también podría aprovechar el join() método proporcionado por el Clase de cadena para imprimir elementos de matriz, sin los corchetes, y separados por un delimitador de elección (que es el carácter de espacio para el ejemplo que se muestra a continuación):

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

La salida será "Hey there amigo!".


35
2017-10-05 19:13



Arrays.deepToString(arr) solo imprime en una línea.

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

Para obtener una tabla para imprimir como una tabla bidimensional, tenía que hacer esto:

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

Parece que el Arrays.deepToString(arr) método debe tomar una cadena de separación, pero desafortunadamente no.


27
2018-03-11 05:36



Arrays.toString

Como una respuesta directa, la solución provista por varios, incluido @Esko, utilizando el Arrays.toString y Arrays.deepToString métodos, es simplemente el mejor.

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

A continuación trato de enumerar algunos de los otros métodos sugeridos, intentando mejorar un poco, y la adición más notable es el uso del Stream.collect operador, utilizando un joining  Collector, para imitar lo que String.join está haciendo.

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

26
2018-06-19 06:10



Antes de Java 8 podríamos haber usado Arrays.toString(array) para imprimir una matriz dimensional y Arrays.deepToString(array) para matrices multidimensionales. Tenemos la opción de Stream y lambda en Java 8 que también se puede usar para imprimir la matriz.

Impresión de una matriz dimensional:

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

El resultado es:

[1, 2, 3, 4, 5]
  [John, Mary, Bob]
  1
  2
  3
  4
  5
  John
  María
  Chelín

Impresión de matriz multidimensional En caso de que deseemos imprimir una matriz multidimensional, podemos usar Arrays.deepToString(array) como:

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

Ahora el punto a observar es que el método Arrays.stream(T[]), que en el caso de int[] nos devuelve Stream<int[]> y luego método flatMapToInt() mapea cada elemento del flujo con los contenidos de un flujo mapeado producido al aplicar la función de mapeo proporcionada a cada elemento.

El resultado es:

[[11, 12], [21, 22], [31, 32, 33]]
  [[John, Bravo], [Mary, Lee], [Bob, Johnson]]
  11
  12
  21
  22
  31
  32
  33
  John
  Bravo
  María
  Sotavento
  Chelín
  Johnson


23
2018-01-24 04:25



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

17
2017-08-07 14:05