Aprender a programar unsando arreglo y matrices en java

Aunque ya en entradas antiguas he publicado ejemplos con arreglos y matrices usando java,  faltó hacer un pequeño tutorial del uso de los mismo, y digo pequeño porque en Internet hay mucha información sobre éste tema y mi interés es redactar un artículo fácil de entender que te ayudará a crear una base sólida y comprender ejemplos más complejos con los que te puedas topar en el futuro.

Podemos empezar definiendo arreglos como una colección de cosas, donde ésas cosas pueden ser variables u objetos, para el caso que Java solo puedes guardar en un arreglo un tipo de variable u objeto.

Los arreglos se usan para almacenar datos y posteriormente recuperarlos fácilmente y cómodamente, por ejemplo si deseamos tener a la mano una lista de nombres de personas podemos crear un arreglo de tipo String, si queremos almacenar una lista de valores enteros podemos crear un arreglo de tipo int, si queremos tener una lista de personas podemos crear un arreglo de tipo Persona; así puedes hacer lista de botones (JButton), iconos (Icon) y cualquier cosa que necesites.

Una de las características que hay que tener en cuenta al momento que usar un arreglo es que se debe especificar la cantidad de elementos que vamos a almacenar, en otras palabras especificar su tamaño; si intentamos almacenar más de lo que puede soportar el arreglo se generará una excepción y al tiempo un error de lógica.

Figura que usaremos para representar arreglos

Usando código, para crear una arreglo usamos la siguiente sintaxis:

<tipo_variable_u_objeto> <nombre_arreglo>[];

y para inicializar el arreglo y especificar su tamaño usamos la siguiente sintaxis:

<nombre_arreglo> = new <tipo_variable_u_objeto>[tamaño]; 

cabe aclarar que podemos crear el arreglo e inicializar al mismo tiempo así:

<tipo_variable_u_objeto> <nombre_arreglo>[] = new <tipo_variable_u_objeto>[tamaño];

Algo muy importante que  tenemos que tener en cuenta antes de pasar con los ejemplos, es que cuando inicializamos nuestro arreglo cada espacio es llenado con valores predeterminados, para el caso que nuestro arreglo sea de tipo número serán llenados con ceros (0) y sin son objetos con valores nulos (null), en la categoría de objetos se incluyen los de tipo String.

Para almacenar o acceder a las posiciones de un arreglo usamos indices que para Java inician en 0 y terminan en (tamaño_del_arreglo - 1) .

Imaginemos que necesitamos almacenar una lista de 5 números y luego mostrarlos en la pantalla, el código nos quedaría de la siguiente forma:

public class EjemploArreglo{
 public static void main(String args[]){
  int arregloDeNumeros[];//Creamos en arreglo
  int tamaño = 5;
  
  arregloDeNumeros = new int[tamaño];//Inicializamos y establecemos un tamaño
  
  //demostramos que el valor predeterminado es 0
  System.out.println("Predeterminado para la posicion 0 => " + arregloDeNumeros[0]);
  
  arregloDeNumeros[0] = 2;//Almacenando en la posicion 0
  arregloDeNumeros[1] = 54;//Almacenando en la posicion 1
  arregloDeNumeros[2] = 56;//Almacenando en la posicion 2
  arregloDeNumeros[3] = 45;//Almacenando en la posicion 3
  arregloDeNumeros[4] = 78;//Almacenando en la posicion 4
  
  System.out.println("Imprimiendo en pantalla");
  for(int i = 0;i < tamaño;i++){ //Recorremos el arreglo tantas veces con elementos tenga
   System.out.println(arregloDeNumeros[i]);
  }
 }
}

Cabe anotar que también que podemos llenar nuestro arreglo con nuestros propios valores predeterminados que es igual que decir "inicializarlo con valores de manera implícita", así:

public class EjemploArreglo{
 public static void main(String args[]){
  int arregloDeNumeros[] = {2,54,56,45,78};
  
  //De ésta forma podemos saber el tamaño de cualquier arreglo
  //Util cuando el usuario final establece el tamaño y deseamos conocerlo
  int tamaño = arregloDeNumeros.length;
  
  System.out.println("Tamaño del arreglo " + tamaño);
  
  System.out.println("Imprimiendo en pantalla");
  for(int i = 0;i < tamaño;i++){ //Recorremos el arreglo tantas veces con elementos tenga
   System.out.println(arregloDeNumeros[i]);
  }
 }
}

Lo expuesto hasta aquí es básico pero suficiente para que pruebes con otros tipos de objetos y variables distinto a numero (int), recorrer los elementos y modificarlos.

Ahora pasemos a las matrices, también llamadas tablas y más técnicamente arreglos bidimensionales; aunque suene un poco extraño una matriz es un array de array's, es decir un arreglo que contiene arreglos, para ilustrar mejor veamos la siguiente figura.

Representación de matrices

Si miramos el ejemplo anterior, tenemos una matriz de 8 filas y 8 columnas, Java vería algo así:

[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ]

La forma de crear, inicializar y recorrer una matriz de este tipo es:

public class EjemploArreglo{
 public static void main(String args[]){
  String matrizDeLetras[][];
  int filas = 4;
  int columnas = 3;
  matrizDeLetras = new String[filas][columnas];
  
  //String matrizDeLetras[][] = new String[4][3]; podemos crear e inicializar de una vez
  
  matrizDeLetras[0][0] = "A";
  matrizDeLetras[0][1] = "B";
  matrizDeLetras[0][2] = "C";
  
  matrizDeLetras[1][0] = "D";
  matrizDeLetras[1][1] = "E";
  matrizDeLetras[1][2] = "F";
  
  matrizDeLetras[2][0] = "G";
  matrizDeLetras[2][1] = "H";
  matrizDeLetras[2][2] = "I";
  
  matrizDeLetras[3][0] = "J";
  matrizDeLetras[3][1] = "K";
  matrizDeLetras[3][2] = "L";
  
  for(int i = 0;i < filas;i++){//El incremento de la i representa el paso por las filas
   for(int j = 0;j < columnas;j++){//El incremento de la j representa el paso por cada columna de i fila
    System.out.print(matrizDeLetras[i][j]);//Imprimimos en pantalla el valor de fila i, columna j
   }
   System.out.println();//Damos un salto de linea
  }  
 }
}

Hasta ahora lo visto aquí sobre matrices muestra que cada fila tiene un número homogéneo o iguales de columnas, a éste tipo de matrices se les denomina matrices regulares, y como te puedes imaginar existe una contraparte llamada matrices irregulares en las cuales el número de columnas por filas es distinto; usare la siguiente figura para ilustrar.

Representación de una matriz irregular

Si miramos el ejemplo anterior, tenemos una matriz de 5 filas, Java vería algo así:

[ [A] ],
[ [B][C][D] ],
[ [E][F] ],
[ [G] ],
[ [H][I][J] ]

La forma de crear, inicializar, llenar y recorrer una matriz irregular la describo en el siguiente código:

public class EjemploArreglo{
 public static void main(String args[]){
  String matrizDeLetrasIrregular[][];
  int filas = 5;
  
  matrizDeLetrasIrregular = new String[filas][];
  
  matrizDeLetrasIrregular[0] = new String[1];//Le asignamos a la fila cero, una columna
  matrizDeLetrasIrregular[1] = new String[4];//Le asignamos a la fila uno, cuatro columnas
  matrizDeLetrasIrregular[2] = new String[2];//Le asignamos a la fila dos, dos columnas
  matrizDeLetrasIrregular[3] = new String[1];//Le asignamos a la fila tres, una columna
  matrizDeLetrasIrregular[4] = new String[3];//Le asignamos a la fila cuatro, tres columnas
  
  //Llenamos la primera fila
  matrizDeLetrasIrregular[0][0] = "A";
  
  //Llenamos la segunda fila
  matrizDeLetrasIrregular[1][0] = "B";
  matrizDeLetrasIrregular[1][1] = "C";
  matrizDeLetrasIrregular[1][2] = "D";
  matrizDeLetrasIrregular[1][3] = "E";
  
  //Llenamos la tercera fila
  matrizDeLetrasIrregular[2][0] = "F";
  matrizDeLetrasIrregular[2][1] = "G";

  //Llenamos la cuarta fila
  matrizDeLetrasIrregular[3][0] = "H";

  //Llenamos la quinta fila
  matrizDeLetrasIrregular[4][0] = "I";
  matrizDeLetrasIrregular[4][1] = "J";
  matrizDeLetrasIrregular[4][2] = "K";
  
  //matrizDeLetrasIrregular.length me indica cuantas filas tiene la matriz
  for(int i = 0;i < matrizDeLetrasIrregular.length;i++){
   //matrizDeLetrasIrregular[i].length me indica cuantas columnas tiene la matriz en la fila i
   for(int j = 0;j < matrizDeLetrasIrregular[i].length;j++){
    System.out.print(matrizDeLetrasIrregular[i][j]);//Imprimimos en pantalla el valor de fila i, columna j
   }
   System.out.println();//Damos un salto de linea
  }  
 }
}

Para terminar quiero agregar que de la misma forma como recorremos las listas y matrices para imprimir sus valores en pantalla, podemos usarlo de manera similar para llenarlos.

Espero sus comentario y sugerencias.

Como siempre, esperando serles de utilidad.