CÓMO IMPRIMIR ARREGLOS EN JAVA: MÉTODOS Y EJEMPLOS

November 9, 2025

Introducción a la Impresión de Arreglos en Java

Los arreglos son una estructura de datos fundamental en Java, diseñada para almacenar elementos del mismo tipo en ubicaciones de memoria contiguas. En Java, los arreglos son objetos, lo que significa que heredan métodos de la clase Object, pero su impresión directa con System.out.println() no produce resultados legibles. En este tutorial, exploraremos cómo imprimir arreglos en Java de manera efectiva, utilizando métodos como bucles, Arrays.toString(), Arrays.deepToString(), Arrays.asList(), el interfaz Iterator y la API Stream. Cada técnica se explicará con ejemplos prácticos para facilitar su comprensión y aplicación en proyectos de programación.

¿Por Qué No Podemos Imprimir Arreglos Directamente?

Cuando intentamos imprimir un arreglo en Java utilizando System.out.println(), no obtenemos los elementos del arreglo, sino una representación confusa. Por ejemplo:

int[] intArray = {2, 5, 46, 12, 34};
System.out.println(intArray);

[I@74a14482

Este resultado se debe a que System.out.println() convierte el objeto en una cadena llamando al método toString() del arreglo. En Java, los arreglos no sobrescriben el método toString() de la clase Object. El método Object.toString() devuelve una cadena con el formato: nombre de la clase seguido de “@” y el código hash del objeto en formato hexadecimal. En el ejemplo anterior, [I indica que es un arreglo de tipo int, y 74a14482 es el código hash del objeto.

Para obtener una representación legible de los elementos de un arreglo, debemos usar métodos específicos que detallaremos a continuación. Estos métodos son esenciales para cualquier desarrollador que desee manipular e imprimir arreglos en Java de manera eficiente.

Uso de Bucles para Imprimir Arreglos

Los bucles son una forma clásica y directa de imprimir los elementos de un arreglo. Los dos tipos más comunes son el bucle for tradicional y el bucle for-each. Ambos permiten recorrer los elementos del arreglo de manera controlada.

Bucle for Tradicional

El bucle for utiliza un índice para acceder a cada elemento del arreglo. Este enfoque es útil cuando necesitamos controlar el índice o realizar operaciones adicionales durante la iteración.

int[] intArray = {2, 5, 46, 12, 34};
for (int i = 0; i < intArray.length; i++) {
    System.out.print(intArray[i] + " ");
}

2 5 46 12 34

En este ejemplo, el bucle accede a cada elemento mediante el índice i y lo imprime con un espacio para mejorar la legibilidad. La propiedad length del arreglo determina el número de iteraciones.

Bucle for-each

El bucle for-each es más conciso y está diseñado para recorrer colecciones o arreglos sin necesidad de un índice explícito. Es ideal para tareas simples de impresión.

int[] intArray = {2, 5, 46, 12, 34};
for (int num : intArray) {
    System.out.print(num + " ");
}

2 5 46 12 34

Ambos bucles son efectivos para arreglos unidimensionales, pero requieren un manejo manual para agregar formato, como comas o corchetes, si se desea imitar la salida de métodos más avanzados.

Método Arrays.toString()

El método Arrays.toString(), perteneciente al paquete java.util.Arrays, es una solución práctica para imprimir arreglos unidimensionales en Java. Este método convierte un arreglo en una cadena con un formato legible, encerrando los elementos entre corchetes y separándolos con comas.

import java.util.Arrays;

int[] intArray = {2, 5, 46, 12, 34};
System.out.println(Arrays.toString(intArray));

[2, 5, 46, 12, 34]

Este método convierte cada elemento del arreglo a una cadena utilizando String.valueOf(). Para arreglos de tipos primitivos, como int o double, los valores se convierten directamente. Sin embargo, para arreglos de tipos de referencia, es crucial que la clase correspondiente sobrescriba el método toString() para evitar una salida ilegible.

Por ejemplo, consideremos una clase personalizada Student:

class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{name='" + name + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        Student[] students = {new Student("John"), new Student("Doe")};
        System.out.println(Arrays.toString(students));
    }
}

[Student{name='John'}, Student{name='Doe'}]

Si la clase Student no sobrescribe toString(), la salida sería una representación hexadecimal de los objetos, similar a la de un arreglo sin procesar.

El método Arrays.toString() no es adecuado para arreglos multidimensionales, ya que trata cada subarreglo como un objeto y llama a su método toString(), produciendo una salida confusa.

int[][] multiDimensionalArr = {{2, 3}, {5, 9}};
System.out.println(Arrays.toString(multiDimensionalArr));

[[I@74a14482, [I@1540e19d]

Para arreglos multidimensionales, debemos usar Arrays.deepToString().

Método Arrays.deepToString()

El método Arrays.deepToString(), también del paquete java.util.Arrays, está diseñado para imprimir arreglos multidimensionales en Java. Este método maneja arreglos anidados de manera recursiva, convirtiendo cada subarreglo en una cadena legible.

import java.util.Arrays;

int[][] multiDimensionalArr = {{2, 3}, {5, 9}};
System.out.println(Arrays.deepToString(multiDimensionalArr));

[[2, 3], [5, 9]]

Para arreglos multidimensionales de tipos primitivos, Arrays.deepToString() utiliza Arrays.toString() para cada subarreglo. Para arreglos de tipos de referencia, como objetos personalizados, el método invoca toString() de cada elemento de manera recursiva, por lo que es fundamental que las clases de los objetos sobrescriban este método.

Por ejemplo:

class Teacher {
    private String name;

    public Teacher(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{name='" + name + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        Teacher[][] teachers = {{new Teacher("John"), new Teacher("David")}, {new Teacher("Mary")}};
        System.out.println(Arrays.deepToString(teachers));
    }
}

[[Teacher{name='John'}, Teacher{name='David'}], [Teacher{name='Mary'}]]

El método Arrays.deepToString() también puede usarse para arreglos unidimensionales, aunque no es necesario, ya que Arrays.toString() es suficiente y más específico para este caso.

import java.util.Arrays;

Integer[] oneDimensionalArr = {1, 4, 7};
System.out.println(Arrays.deepToString(oneDimensionalArr));

[1, 4, 7]

Método Arrays.asList()

El método Arrays.asList() convierte un arreglo en una lista de tamaño fijo respaldada por el arreglo original. Esta lista puede imprimirse directamente, ya que la clase List sobrescribe el método toString() para mostrar los elementos de manera legible.

import java.util.Arrays;

Integer[] intArray = {2, 5, 46, 12, 34};
System.out.println(Arrays.asList(intArray));

[2, 5, 46, 12, 34]

Es importante notar que Arrays.asList() requiere un arreglo de tipos de referencia, como Integer, en lugar de tipos primitivos como int. Esto se debe a que las listas en Java trabajan con objetos, no con tipos primitivos. Si intentamos usar un arreglo de int, obtendremos una lista que contiene el arreglo completo como un solo elemento.

int[] intArray = {2, 5, 46, 12, 34};
System.out.println(Arrays.asList(intArray));

[[I@74a14482]

Para arreglos de objetos personalizados, el método funciona correctamente siempre que la clase sobrescriba toString().

class Teacher {
    private String name;

    public Teacher(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{name='" + name + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        Teacher[] teachers = {new Teacher("John"), new Teacher("Mary")};
        System.out.println(Arrays.asList(teachers));
    }
}

[Teacher{name='John'}, Teacher{name='Mary'}]

Sin embargo, Arrays.asList() no es adecuado para arreglos multidimensionales, ya que trata cada subarreglo como un objeto, produciendo una salida ilegible similar a la de Arrays.toString() para estos casos.

Teacher[][] teachers = {{new Teacher("John"), new Teacher("David")}, {new Teacher("Mary")}};
System.out.println(Arrays.asList(teachers));

[[LTeacher;@1540e19d, [LTeacher;@677327b6]

Interfaz Iterator para Imprimir Arreglos

La interfaz Iterator proporciona una forma de recorrer los elementos de una colección, como una lista creada a partir de un arreglo con Arrays.asList(). Este enfoque es similar al bucle for-each, pero ofrece mayor flexibilidad en escenarios donde se necesita controlar la iteración manualmente.

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

Integer[] intArray = {2, 5, 46, 12, 34};
List<Integer> list = Arrays.asList(intArray);
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + " ");
}

2 5 46 12 34

El método iterator() devuelve un objeto Iterator que permite recorrer los elementos de la lista utilizando hasNext() para verificar si hay más elementos y next() para obtener el siguiente elemento. Este enfoque es útil cuando se trabaja con colecciones más complejas, pero para arreglos simples, los bucles o Arrays.toString() suelen ser más prácticos.

API Stream de Java

La API Stream de Java, introducida en Java 8, ofrece una manera moderna y funcional de procesar colecciones, incluyendo arreglos. El método Arrays.stream() convierte un arreglo en un flujo (Stream), y la operación terminal forEach() permite realizar acciones sobre cada elemento, como imprimirlo.

import java.util.Arrays;

Integer[] intArray = {2, 5, 46, 12, 34};
Arrays.stream(intArray).forEach(num -> System.out.print(num + " "));

2 5 46 12 34

La API Stream es especialmente útil para operaciones más complejas, como filtrado o transformación, pero para la simple tarea de imprimir un arreglo, puede ser más verbosa que Arrays.toString(). Sin embargo, su sintaxis funcional es atractiva para desarrolladores que prefieren un enfoque declarativo.

Para arreglos multidimensionales, podemos usar Arrays.stream() con flatMap() para aplanar el arreglo y luego imprimirlo.

import java.util.Arrays;

int[][] multiDimensionalArr = {{2, 3}, {5, 9}};
Arrays.stream(multiDimensionalArr)
      .flatMapToInt(Arrays::stream)
      .forEach(num -> System.out.print(num + " "));

2 3 5 9

Este ejemplo aplana el arreglo bidimensional en un flujo de enteros y los imprime. Sin embargo, para mantener la estructura del arreglo multidimensional, Arrays.deepToString() sigue siendo la mejor opción.

Comparación de Métodos

Cada método para imprimir arreglos en Java tiene sus ventajas y limitaciones:

Bucles (for y for-each): Ofrecen control total sobre el formato de salida, pero requieren más código y no producen una representación estandarizada con corchetes y comas.
Arrays.toString(): Ideal para arreglos unidimensionales, con una salida clara y concisa, pero no funciona para arreglos multidimensionales.
Arrays.deepToString(): Perfecto para arreglos multidimensionales, manejando la recursión automáticamente.
Arrays.asList(): Útil para arreglos unidimensionales de tipos de referencia, pero no soporta arreglos multidimensionales ni tipos primitivos directamente.
Iterator: Proporciona flexibilidad para recorrer arreglos convertidos en listas, pero es más complejo que los bucles simples.
API Stream: Moderna y funcional, ideal para operaciones complejas, pero puede ser excesiva para la simple impresión de arreglos.

La elección del método depende del tipo de arreglo, el formato deseado y el contexto del proyecto. Para la mayoría de los casos, Arrays.toString() y Arrays.deepToString() son las opciones más prácticas debido a su simplicidad y claridad.

Mejores Prácticas

Cuando trabajes con arreglos en Java, considera las siguientes recomendaciones:

Sobrescribe toString() para clases personalizadas: Si tus arreglos contienen objetos personalizados, asegúrate de que la clase sobrescriba el método toString() para obtener una representación legible.
Usa Arrays.toString() para arreglos unidimensionales: Es la forma más directa de obtener una salida formateada para arreglos simples.
Prefiere Arrays.deepToString() para arreglos multidimensionales: Evita resultados ilegibles al trabajar con arreglos anidados.
Considera la API Stream para flujos de trabajo funcionales: Si tu proyecto utiliza un enfoque funcional, la API Stream puede integrarse bien, aunque no siempre es la opción más simple.
Evalúa la legibilidad y el rendimiento: Para tareas simples, los bucles pueden ser suficientes, pero para salidas estandarizadas, los métodos de la clase Arrays son más adecuados.

Conclusiones

Imprimir arreglos en Java puede parecer un desafío al principio debido a la salida predeterminada de System.out.println(), pero las herramientas proporcionadas por el lenguaje, como los bucles, Arrays.toString(), Arrays.deepToString(), Arrays.asList(), la interfaz Iterator y la API Stream, ofrecen soluciones versátiles para diferentes escenarios. Al comprender las fortalezas y limitaciones de cada método, los desarrolladores pueden elegir la técnica más adecuada para sus necesidades, ya sea para depuración, presentación de datos o integración en aplicaciones más complejas. Con estas herramientas, manejar arreglos en Java se convierte en una tarea accesible y eficiente, mejorando la calidad del código y la experiencia del desarrollador.