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 |
[ [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 |
[ [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.
