Uso de Arrays: Ejemplo práctico

En este post iremos conociendo de un modo práctico que es y como se utiliza un Array en java, para esto partiremos de un proyecto realizado en Netbeans (o puede utilizar el IDE de tu preferencia) que consta de dos clases, la clase Main y una clase que llamaremos Raton 🙂

El código de la clase Raton es el siguiente:

public class Raton {

    private String name;

    /**
     * Constructor de clase
     * @param name nombre del raton
     */
    public Raton(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

}

¿Que es un Array y como se declara?

Una Array es un objeto contenedor, es decir contiene un número fijo de valores primitivos u objetos de un solo tipo.

Para declarar un array de solo ratones, escribimos el siguiente código en la clase Main:

public static void main(String[] args) {        
    Raton[] ratones = new Raton[3];
    System.out.println(ratones[1]);        
}

Si ejecutamos el código anterior, veremos que obtendremos un NULL en consola, esto pasa porque solo declaramos los espacios para nuestros ratones, pero no hay ningún ratón todavía.

Para agregar ratones en nuestro array, procedemos de la siguiente manera:

Raton[] ratones = new Raton[3];
         
ratones[0] = new Raton("Juan");
ratones[1] = new Raton("Maria");
ratones[2] = new Raton("Pedro");
        
System.out.println(ratones[1]);

Y ahora volvemos a ejecutar el Main y obtenemos: Raton [name=Maria] que corresponde al nombre del ratón en la casilla (indice) 1.

Otra alternativa para declarar Arrays en java es la siguiente:

Raton[] ratones = {new Raton("Juan"),
                   new Raton("Maria"),
                   new Raton("Pedro")};
        
System.out.println(ratones[1]); 

En donde la longitud del Array esta determinado por la cantidad de objetos separados por comas dentro de los llaves.

Existe otra manera más de declarar arrays, pero la misma Oracle no la recomienda y por tanto debemos evitar usarla, esa sintaxis es la siguiente:

Raton ratas[] = new Raton[3];

¿Como recorremos uno a uno los elementos de un array?

Podemos utilizar el ciclo FOR de la siguiente manera:

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

o también el FOR extendido:

for (Raton r : ratones) {
     System.out.println( r );
}

Y el resultado en pantalla para cualquiera de esas opciones sera:

Raton [name=Juan]
Raton [name=Maria]
Raton [name=Pedro]

Array Multidimensionales

Los Arrays multidimensiones o Array de Arrays en java son arreglos que tienen más de una dimensión, el más usado o más conocido es la Matriz bidimensional NxM.

//matriz 2x3 : 2 filas x 3 columnas
Raton[][] ratones = new Raton[2][3];
//fila 1
ratones[0][0] = new Raton("Lucas");
ratones[0][1] = new Raton("Camila");
ratones[0][2] = new Raton("Pedro");
//fila 2
ratones[1][0] = new Raton("Juan");
ratones[1][1] = new Raton("Luisa");

System.out.println(ratones[0][2]);//Pedro   

representado en forma gráfica se vería de la siguiente forma:

Vemos que tanto las filas como las columnas empiezan en cero «0», también vemos que no es necesario llenar todas las casillas, la celda [1][2] esta vacío (null). Para localizar un elemento en la matriz se usa las coordenadas [fila][columna] donde [fila:0][columna:2]=Pedro

Para conocer la cantidad de filas que tiene una matriz se utiliza matriz.length  en nuestro ejemplo seria ratones.length, lo que nos dará un entero «2», para las columnas en cambio se utilizara ratones[0].length y nos dará un «3».

Al igual que ocurre con el array de una dimensión, los array multidimensionales pueden declararse usando llaves, por ejemplo la matriz de arriba puede escribir de la siguiente forma:

//matriz 2x3 : 2 filas x 3 columnas
Raton[][] ratones = { 
    {new Raton("Lucas"), new Raton("Camila"), new Raton("Pedro")},
    {new Raton("Juan"), new Raton("Luisa")}
};
System.out.println(ratones[0][2]);//Pedro   

Las matrices de más de dos dimensiones no son muy frecuentes pero si posibles, por ejemplo una matriz con 4 dimensiones se declararía:

Raton[][][][] ratones = new Raton[4][3][6][12];

¿Y su recorrido?

Para recorrer array multidimensionales se usan tantos ciclos FOR como sean necesarios, por ejemplo nuestra matriz de ratones 2×3 se puede recorrer de la siguiente manera:

for(int fila=0; fila<ratones.length; fila++){
    for(int col=0; col<ratones[fila].length; col++ ){                
        System.out.print( ratones[fila][col] + " | ");                
    }
    System.out.println();
}

Y usando un For extendido:

for (Raton[] r : ratones) {
    for (Raton value : r) {
        System.out.print( value + " | ");
    }
    System.out.println();
}

Utilizando cualquiera de esas opciones tenemos:

enjoy!!!