Java - Cómo imprimir una matriz en una línea

En este breve tutorial, veremos cómo imprimir una matriz en una sola línea en Java, usando Arrays.toString(), Arrays.deepToString(), Stream API y otros métodos.

Introducción

Java es un lenguaje detallado y con seguridad de tipos. Hay ventajas en esto, pero también algunos inconvenientes. Es decir, a menudo hay una gran cantidad de código repetitivo y las operaciones simples, como imprimir una matriz, no son tan simples como proporcionarlo al método println ():

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

Esto da como resultado los valores hash de la referencia del objeto en la memoria, no su contenido:

1
[[correo electrónico protegido]

Esto se debe a que las matrices de Java no anulan el método toString() de la clase Object y solo devuelven el hash del objeto en sí. Esta es una característica que obviamente falta en el lenguaje, y no está exactamente claro por qué faltaría tal característica, especialmente con otros lenguajes que tienen soporte para imprimir estructuras de datos tan fundamentales.

En esta guía, veremos varias formas de imprimir arreglos en una línea, utilizando los métodos auxiliares integrados y la API de transmisión, sopesando las diferencias entre los enfoques y cuándo usar cuál.

Arreglos.toString()

La forma más simple y directa de imprimir una matriz en una sola línea es usar la clase auxiliar Arrays, que reside en el paquete java.util:

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

Bajo el capó, utiliza un ‘StringBuilder’ para agregar cada elemento a través de un simple bucle ‘for’, y obtienes un resultado que podrías esperar al imprimir una matriz tal como está:

1
[1, 2, 3, 4, 5, 6]

{.icon aria-hidden=“true”}

Nota: Este enfoque falla en matrices anidadas, en cuyo caso, un elemento es una matriz, por lo que se agrega su referencia al objeto en la memoria en lugar de su contenido.

Entonces, esta matriz 2D no se puede imprimir con Arrays.toString():

1
2
int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.toString(array));

Y da como resultado:

1
[[[correo electrónico protegido], [[correo electrónico protegido]]

Arrays.deepToString()

Si desea trabajar con arreglos anidados, puede usar el método deepToString() en su lugar:

1
2
int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.deepToString(array));

Esto da como resultado el resultado esperado:

1
[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]

Imprimir matriz en una línea con Java Streams

Arrays.toString() y Arrays.toDeepString() solo imprimen el contenido de manera fija y se agregaron como métodos convenientes que eliminan la necesidad de crear un bucle manual for. Sin embargo, al imprimir, es posible que desee formatear un poco la salida o realizar operaciones adicionales en los elementos mientras los revisa.

La API Stream se agregó en Java 8, como uno de los primeros pasos en la introducción del paradigma de programación funcional en Java. Generalmente, al imprimir una matriz con un Stream, llamarás al método forEach(), aunque hay múltiples formas de [obtener un Stream de un Array](/java-convertir-matriz-a-flujo /).

Si desea leer más sobre el método forEach(), lea nuestra Guiado a Stream.forEach() en Java!

La forma más sencilla de obtener un Stream de un Array es el método Stream.of(), que también se puede usar con otras colecciones (pero depende del tipo de datos), aunque también se puede usar Arrays.stream() (más robusto) o convertir la matriz en una lista y transmitirla (aunque un poco redundante) a través de Arrays.asList().stream().

De todos estos, lo más probable es que utilice el método Arrays.stream(), ya que no se preocupa de si los elementos son de un tipo primitivo o un objeto, lo cual es una preocupación cuando se usa Método Stream.of().

Con Stream.of(), dependiendo del tipo de datos que estés usando, usarás un Stream o una variante derivada, como IntStream. Esto es importante, para que el código no devuelva un hash en lugar del contenido.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
int[] intArray = new int[]{1, 2, 3, 4, 5, 6};
String[] objArray = new String[]{"Java", "Python", "JavaScript"};

// If using Stream.of(), primitive types need to be flatmapped
Stream.of(intArray).flatMapToInt(Arrays::stream).forEach(System.out::print);
IntStream.of(intArray).forEach(System.out::print);
// Stream.of() with objects
Stream.of(objArray).forEach(System.out::print);

// Arrays.stream() works with both primitive types and objects
Arrays.stream(intArray).forEach(System.out::print);
Arrays.stream(objArray).forEach(System.out::print);

// If using asList(), primitive types need to be flatMapped
Arrays.asList(intArray).stream().flatMapToInt(Arrays::stream).forEach(System.out::print);
Arrays.asList(objArray).stream().forEach(System.out::print);

Todo esto da como resultado:

1
2
123456
JavaPythonJavaScript

En términos generales, el método Arrays.stream() es el más seguro de usar y también es el más corto/legible.

Aunque no está muy estilizado en este momento, el uso de Streams le permite agregar cualquier operación intermediaria en la canalización, por lo que si desea recopilarlos con un delimitador, por ejemplo, podría usar un Collector:

1
System.out.println(Arrays.stream(objArray).collect(Collectors.joining(",")));

Esto resulta en:

1
Java,Python,JavaScript

Puede ser creativo aquí, con múltiples operaciones, como transformar los valores, filtrarlos y luego unirlos:

1
2
3
4
5
6
String[] objArray = new String[]{"Java", "Python", "JavaScript"};

System.out.println(Arrays.stream(objArray)
        map(String::toUpperCase)
        filter(e -> e.startsWith("J"))
        collect(Collectors.joining(",")));

Que asigna todos los elementos a sus contrapartes en mayúsculas, filtra dado un predicado (que un elemento comienza con "J") y luego los une con un delimitador:

1
JAVA,JAVASCRIPT

Conclusión

En esta guía, hemos analizado cómo imprimir una matriz en Java en una sola línea, una función que falta de forma predeterminada.

Hemos echado un vistazo a cómo imprimir arreglos a través de los métodos auxiliares integrados de la clase Arrays, así como también cómo utilizar la API Stream para personalizar este proceso.

Licensed under CC BY-NC-SA 4.0