Cómo imprimir una matriz en Java

En este tutorial, imprimiremos arreglos en Java utilizando los métodos toString() y deepToString(), flujos, bucles e iteradores, ¡con ejemplos y explicaciones!

Introducción

Imprimir una matriz es una forma rápida de darnos visibilidad sobre los valores de los contenidos dentro. A veces, los valores de la matriz son la salida deseada del programa.

En este artículo, veremos cómo imprimir una matriz en Java usando cuatro formas diferentes.

Si bien la "mejor manera" depende de lo que su programa necesite hacer, comenzamos con el método más simple para imprimir y luego mostramos formas más detalladas de hacerlo.

Imprime una matriz usando Arrays.toString() y Arrays.deepToString()

El método incorporado toString() es una forma extremadamente simple de imprimir versiones formateadas de objetos en Java.

Cada tipo de datos en Java se considera una clase y, por defecto, cada clase hereda de java.lang.Object, la raíz de la jerarquía de clases de Java. Es por eso que cada clase tiene un método toString(). Sin embargo, las matrices no anulan el método toString() para formatear bien la salida, y solo devuelve el valor heredado, que es el hash del objeto.

Imprimimos arreglos usando el método toString() de la clase en java.util.Arrays.

Tome este ejemplo donde imprimimos los valores de una matriz de enteros:

1
2
3
int[] intSequence = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

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

El código anterior generará lo siguiente:

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

Observe cómo todos los elementos están separados por comas y entre corchetes. Este método es como una representación visual de la matriz.

También podemos usar este método para imprimir matrices de diferentes tipos:

1
2
3
4
5
double[] doubleValues = {5.5, 2.37, 9.9, 1.02};
System.out.println(Arrays.toString(doubleValues));
        
String[] stringValues = {"alabama", "arkansas", "kentucky"};
System.out.println(Arrays.toString(stringValues));

Estos dan como resultado respectivamente:

1
2
[5.5, 2.37, 9.9, 1.02]
[alabama, arkansas, kentucky]

El método toString() solo es efectivo para arreglos unidimensionales. Cuando tenemos arreglos anidados, necesitamos usar el método deepToString():

1
2
3
4
5
double[][] coordinates = {{40.50, 50.75}, {22.25, 32.75}};
System.out.println(Arrays.deepToString(coordinates));
        
String[][] songLines = {{"Take your nose off my keyboard"}, {"What you bothering me for?"}};
System.out.println(Arrays.deepToString(songLines));

Estos dan como resultado:

1
2
[[40.5, 50.75], [22.25, 32.75]]
[[Take your nose off my keyboard], [What you bothering me for?]]

Si necesita una visualización de lo que hay en su matriz de un vistazo, los métodos toString() y deepToString() son su mejor opción.

Sin embargo, estos métodos no le permiten formatear su salida. Este enfoque es básicamente una solución al hecho de que las matrices no anulan el método toString() de forma predeterminada.

Si prefiere cierta flexibilidad con el formato, podría considerar usar Java 8 Streams.

Imprima una matriz utilizando flujos de Java 8

Una opción para imprimir una matriz es convertirla en una secuencia de objetos y luego imprimir cada elemento de la secuencia. Tenemos algunas opciones para aprovechar los flujos para imprimir nuestra matriz.

Por ejemplo, podemos imprimir nuestra matriz línea por línea de esta manera:

1
2
String[] languages = {"Java", "Python", "JavaScript"};
Arrays.stream(languages).forEach(System.out::println);

En este caso, usamos el método estático stream() de la clase Arrays para crear un flujo secuencial de nuestros datos. Para cada elemento en nuestro flujo, llamamos a la función println(), haciéndolo aparecer línea por línea así:

1
2
3
Java
Python
JavaScript

Nota: Hacemos referencia a la función println() de la siguiente manera: System.out::println. El :: en Java es un operador de referencia de método. La función forEach() puede usar una función lambda o una referencia de método.

Alternativamente, podemos usar la clase Stream de java.util.stream.Stream para llamar de manera similar a la función println() en una secuencia de nuestra matriz de datos. Podemos construir un Stream de estos datos usando Stream.of():

1
2
String[] languages = {"Java", "Python", "JavaScript"};
Stream.of(languages).forEach(System.out::println);

Con este código obtendremos el mismo resultado:

1
2
3
Java
Python
JavaScript

Probemos esto también con arreglos anidados, agregando las fechas de lanzamiento de las versiones iniciales de estos lenguajes:

1
2
3
4
5
String[][] languages = {{"Java", "1996"}, {"Python", "1994"}, {"JavaScript", "1995"}};

Arrays.stream(languages).forEach(System.out::println);
// OR
Stream.of(languages).forEach(System.out::println);

La salida para cada impresión a través de secuencias se vería así:

1
2
3
[Ljava.lang.String;@e9e54c2
[Ljava.lang.String;@65ab7765
[Ljava.lang.String;@1b28cdfa

Eso no funciona muy bien... Estamos llamando println() en los objetos de la matriz de nuevo. Tendremos que transmitir esos objetos nuevamente e imprimir sus elementos.

Para imprimir matrices anidadas, podemos usar una expresión lambda en la función forEach() que puede ir al segundo nivel, creando otra secuencia de cada nivel e imprimiendo las entradas de esa manera:

1
2
3
4
5
String[][] languages = {{"Java", "1996"}, {"Python", "1994"}, {"JavaScript", "1995"}};
        
Arrays.stream(languages).forEach(s -> Arrays.stream(s).forEach(System.out::println)); 
// OR
Stream.of(languages).forEach(s -> Arrays.stream(s).forEach(System.out::println));

Esta función lambda imprime los elementos en cada matriz anidada. Cuando se compila y ejecuta, obtendríamos este resultado:

1
2
3
4
5
6
Java
1996
Python
1994
JavaScript
1995

Las secuencias hacen que trabajar con colecciones sea muy sencillo. Pero Java es flexible para proporcionar aún más formas. El bucle for tradicional todavía hace mucho por nosotros. Echemos un vistazo a la impresión de una matriz con bucles.

Imprima una matriz convirtiéndola en lista

Puede convertir fácilmente una matriz de Java en una implementación de Lista. Hay varias formas de hacerlo, y hemos cubierto cada una en detalle en nuestro [Cómo convertir una matriz Java a ArrayList](/como-convertir-una-matriz-de-java-a-una-lista-de- matrices/) artículo.

En resumen, llamar a toString(), o simplemente imprimir (que implícitamente llama a toString()) en una implementación de List, imprimirá el contenido:

1
2
3
4
Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> numberList = Arrays.asList(numbers);

System.out.println(numberList);

Esto resulta en:

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

Además, puede usar .forEach() de forma nativa en cualquier Colección, que es una Lista. Entonces, puedes seguir adelante y hacer esto también:

1
2
Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers).forEach(System.out::println);

Sin embargo, esta no es una opción bien formateada:

1
12345678910

Puede deshacerse de la referencia del método y simplemente usar una lambda para tener más control:

1
2
3
Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers)
        .forEach(number -> System.out.print(String.format("%d, ", number)));

Esto resulta en:

1
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 

Imprime una matriz usando For Loops

Un enfoque más conocido para imprimir una matriz en Java es usar un bucle for. Con un ciclo for obtenemos el índice del elemento, y podemos usar el índice para obtener el elemento de una matriz.

Configuramos un bucle for con una variable, comúnmente llamada i, como contador a partir del elemento 0. Esto es seguido por la condición que compara i con el número de elementos en la matriz.

Nota: La cantidad de elementos en la matriz que se usarán en la condición del ciclo nunca debe codificarse de forma rígida. Java proporciona un atributo llamado “longitud” que permite al programador calcular dinámicamente el número de elementos en una matriz.

Por último, pero no menos importante, nuestro ciclo for toma el valor incremental en nuestro caso, usaremos la notación i++ para seguir aumentando nuestro contador en un elemento en cada iteración.

Una vez que nuestro ciclo esté configurado y listo, simplemente usaremos la declaración System.out.println() para mostrar cada elemento en la matriz usando la notación de corchete rectangular [i] tomando como entrada nuestro contador i.

Aquí hay un ejemplo donde imprimimos todos los elementos de una matriz de enteros línea por línea:

1
2
3
4
5
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int i = 0; i < numbers.length; i++){
    System.out.println(numbers[i]);
}

Ejecutar este código imprimiría lo siguiente en su consola:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
1
2
3
4
5
6
7
8
9
10

No hay mucho más que usar bucles for. Son bastante flexibles y conceptualmente simples. Por ejemplo, si tuviera arreglos anidados, usará bucles for anidados.

Finalmente, echemos un vistazo a los iteradores y las listas.

Conversión a lista y uso de un iterador {#conversión a lista y uso de un iterador}

Un objeto iterador de Java nos permite mostrar cada elemento de nuestra matriz sin tener que usar el enfoque de índice que cubrimos en la sección de bucle for.

Para usar iteradores, tenemos que cambiar el tipo de datos de la matriz a una Lista. Podemos hacer esto usando el método Array.asList() y guardar los valores de la lista devueltos en una nueva variable. El método asList() toma la matriz y la convierte en una implementación List.

A continuación, necesitará un objeto iterador para configurar su iterador de matriz. Un iterador es como un puntero que apunta a cada elemento de la matriz. El iterador le ayuda a inspeccionar cada elemento de manera singular.

Para crear un objeto iterador, usaremos el método iterator() de nuestra Lista. Una vez que se creó nuestro objeto iterador, usamos el bucle while, ya que ofrece una forma más compacta de imprimir cada elemento devuelto por el iterador.

La condición del bucle while contendrá una llamada al método hasNext() de nuestro iterador. Dentro del bucle while, imprimimos cada elemento llamando a System.out.println(). Obtenemos elementos del iterador llamando al método next(). El bucle ‘while’ seguirá iterando sobre cada elemento hasta que hayamos recorrido nuestra matriz (a través de la ‘Lista’).

Aquí hay un ejemplo donde tomamos una matriz de enteros e imprimimos cada elemento línea por línea usando un iterador:

1
2
3
4
5
6
7
Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> numberList = Arrays.asList(numbers);
Iterator<Integer> numberIterator = numberList.iterator();

while(numberIterator.hasNext()) {
    System.out.println(numberIterator.next());
}

En comparación con los bucles for, este método es el preferido por los desarrolladores que prefieren no trabajar con índices de matrices. Tiene garantizado el próximo elemento con next(). Los iteradores son poderosos porque usamos este mismo flujo para cualquier tipo de ‘Lista’ como ‘ArrayList’ o ‘LinkedList’, ¡así como para otras colecciones como ‘Mapa’ o ‘Conjunto’!

Conclusión

En este artículo, cubrimos los principales métodos utilizados para imprimir una matriz en Java. Empezamos usando los métodos integrados de Java toString() y deepToString().

A partir de ahí, usamos secuencias para que podamos imprimir rápidamente los elementos de la matriz línea por línea. También hemos cubierto cómo convertir una matriz en una lista, a la que puede simplemente llamar o usar la API de flujo de Java 8 para un control más granular.

Luego, usamos la estructura tradicional de bucle for para imprimir cada elemento individualmente.

Por último, pero no menos importante, usamos el objeto iterador para imprimir cada elemento por separado usando el método next() dentro de un ciclo while. Los enfoques cubiertos en el capítulo se pueden usar según el caso de uso y el problema que está tratando de resolver. .

Licensed under CC BY-NC-SA 4.0