Última actualización: octubre 2024
Continuando con las notas de Java, vamos a ver cómo trabajar con los Arrays en Java. Un array o arreglo, es un grupo de varias variables del mismo tipo que se agrupan bajo un mismo nombre.
Los arrays son útiles porque permiten trabajar con muchos datos de un mismo tipo sin tener que declarar cada variable individualmente. En lugar de crear una variable para cada valor, creamos un array y accedemos a cada dato empleando un número (llamado indice) que indica la posición del dato en el array.
En los arrays, los elementos están ordenados de forma secuencial, y cada posición se identifica con un índice. Los índices del array empiezan siempre con el valor 0 que apunta a la posición 1, el indice de valor 1 apunta a la posición 2 y así sucesivamente.
Accedemos a cada elemento del array utilizando el índice. Por ejemplo, si queremos acceder al elemento del array que ocupa la posición 5, tendríamos que referenciarlo usando el valor 4 para el índice, ya que empezamos a contar desde cero.
Declarar un array
Para poder trabajar con un array, lo primero que tenemos que hacer es declararlo.
Cuando declaramos un array, definimos el tipo de las variables que almacenaremos en el array (recordad que son todas del mismo tipo). A continuación, abrimos y cerramos corchetes, y después escribimos el nombre del array. La sintaxis sería la siguiente:
<type>[] variable_namePor ejemplo, la declaración de un array de enteros llamado misNumeros y de un array de textos llamado nombres sería:
int[ ] misNumeros
String[ ] nombres
Sin embargo, para acabar de crear el array y reservar espacio en memoria para sus valores, hay que especificar el tamaño del mismo. Es decir, cuantas variables del tipo declarado va a contener. La sintaxis es:
variable_name = new type[size]Para los dos arrays anteriores (misNumeros y nombres), suponiendo que el primero va a contener 7 números enteros y el segundo 5 nombres, las instrucciones para crearlos serían:
misNumeros = new int[7]
nombres = new String [5]
Inicializar un array
Para inicializar un array, tenemos dos opciones:
- Lo inicializamos en la misma declaración. Colocamos los valores de los elementos del array entre llaves, como en el ejemplo siguiente:
int[ ] misNumeros = {40, 55, 63, 17, 22, 68, 97, 89};
- Actualizamos el valor para cada elemento del array accediendo a través del índice que indica su posición:
int [] misNumeros;
misNumeros = new int[8];
misNumeros[0]=40; misNumeros[1]=55; misNumeros[2]=63; misNumeros[3]=17; misNumeros[4]=22; misNumeros[5]=68; misNumeros[6]=97; misNumeros[7]=89;
A cada elemento del array se accede a través de su índice. El índice comienza en 0 y finaliza en: tamaño total del array-1
Acceder a los elementos de un array
Una vez declarado e inicializado un array, para poder trabajar con él, necesitamos acceder a los valores que contiene. En cada posición de un array tenemos un valor al que se accede a través del índice, ya sea para recuperar o modificar dicho valor.
Por ejemplo, para recuperar el elemento que ocupa la posición 4 del array misNumeros, se accede a través del indice 3 que se corresponde con esa posición.
int[ ] misNumeros = {40, 55, 63, 17, 22, 68, 97, 89};
int elemento_4=misNumeros[3];
System.out.println("Elemento en posición 4 es :"+elemento_4);
La ejecución de este código daría el resultado:
Elemento en posición 4 es :17
Por el contrario, si lo que queremos es actualizar el elemento en la posición 4 a un nuevo valor, por ejemplo 33. Sencillamente guardamos el nuevo valor en el array a través del indice correspondiente:
int[ ] misNumeros = {40, 55, 63, 17, 22, 68, 97, 89};
misNumeros[3]=33;
System.out.println("Elemento en posición 4 es: "+misNumeros[3]);
Y el resultado de ejecutar estas instrucciones sería:
Elemento en posición 4 es :33
Recorrer un array
Trabajando con arrays, nos encontraremos con varias situaciones en las que sea necesario recorrer todo el array recuperando los elementos de este. Las dos formas más habituales de realizar esta operación son:
- Bucle for clásico: Donde accedemos a los datos del array a través del índice
int[ ] misNumeros = {40, 55, 63, 17, 22, 68, 97, 89};
for (int i=0;i< misNumeros.length;i++){
System.out.println("número en posicion "+(i+1)+" es "+misNumeros[i]);
}
Usamos como limite para el bucle el tamaño del array (misNumeros.length), asegurandonos así que no intentamos acceder con un índice fuera de los límites del array.
- Bucle for-each: Recuperamos directamente todos los elementos del array sin emplear el indice, de forma secuencial de acuerdo al orden que tienen en el array
int[ ] misNumeros = {40, 55, 63, 17, 22, 68, 97, 89};
for (int numero : misNumeros) {
System.out.println("Elemento: " + numero);
}
Cada elemento del array se asigna secuencialmente a la variable numero y se recorre automáticamente todo el array. La principal ventaja de esta solución es que no hay que preocuparse de no cometer el error de intentar acceder con un índice fuera de límites.
Actividad: Practicando con arrays
- Abre el compilador online:
- Introduce el siguiente código:
public class Actividad_Practicando_con_arrays {
public static void main(String[] args) {
int[] numPrimos = {1,2,3,5,7,11,13,17,19,23,29,31};
System.out.println ("Primer elemento: "+numPrimos[0]);
System.out.println ("Quinto elemento: "+numPrimos[4]);
int arrayLength = numPrimos.length;
System.out.println ("Número de elementos en el array: "+arrayLength);
for (int i=0;i<arrayLength;i++){
System.out.println ("El elemento en la posición"+i+" es "+numPrimos[i]);
}
}
}
Línea 3: Declaro e inicializo un array de valores enteros
Línea 4: Dibujamos en la pantalla el valor del primer elemento del array, que ocupa la primera posición y es referenciado por el valor de índice: 0.
Línea 5: Dibujamos por pantalla el valor del elemento en la quinta posición.
Línea 6: Uno de los parámetros de un array es “length” que devuelve la longitud de un array, es decir, el número de elementos que tiene. En esta sentencia guardamos el valor de la longitud del array en la variable arrayLength.
Línea 7: dibujamos en pantalla la longitud del array.
Líneas de la 8 a la 10: Uso un bucle for para recorrer el array empleando su índice, y dibujar todos los elementos del mismo. El bloque for lo veremos en detalle en el cuaderno de Estructuras de control.
- Si ejecutamos el programa, obtendremos el siguiente resultado:
run:
Primer elemento: 1
Quinto elemento: 7
Número de elementos en el array: 12
El elemento en la posición0 es 1
El elemento en la posición1 es 2
El elemento en la posición2 es 3
El elemento en la posición3 es 5
El elemento en la posición4 es 7
El elemento en la posición5 es 11
El elemento en la posición6 es 13
El elemento en la posición7 es 17
El elemento en la posición8 es 19
El elemento en la posición9 es 23
El elemento en la posición10 es 29
El elemento en la posición11 es 31
BUILD SUCCESSFUL (total time: 0 seconds)
- Vamos a practicar ahora con un array de Strings. Es decir, sus elementos serán cadenas de texto.
- Tecleamos el siguiente código:
public class Actividad_Practicando_con_arrays_II {
public static void main(String[] args) {
String[] estudiantes ={"Pedro","Antonio","Lara","Fabiola","Pablo"};
String[] asignaturas;
asignaturas = new String[3];
asignaturas[0]="Matemáticas";
asignaturas[1]="Lengua";
if (asignaturas[2]==null){
System.out.println ("La tercera asignatura no está definida todavia");
}
asignaturas[2]="Quimica";
System.out.println("Los estudiantes son: ");
for (int i=0;i<estudiantes.length;i++){
System.out.println ((i+1)+".- "+estudiantes[i]);
}
System.out.println("Las asignaturas son: ");
for (int i=0;i<asignaturas.length;i++){
System.out.println ((i+1)+".- "+asignaturas[i]);
}
}
}
Línea 3: Declaramos e inicializamos el array “estudiantes” en la misma sentencia. Es un array de Strings, es decir de cadenas de texto. Recordemos que un String era a su vez una cadena de charts.
Línea 4: Declaramos el array “asignaturas”. Es un array de Strings.
Línea 5: Inicializamos el array “asignaturas”. Es decir, reservamos espacio en memoria para un array de 3 Strings.
Línea 6 y 7: Guardamos los valores de los dos primeros elementos del array “asignaturas”. Para el tercer String, que estaría en la posición 3, referenciado por un valor de índice 2, no hemos guardado ningún valor, por lo que el elemento en esa posición contendrá el valor null. Este valor se emplea para indicar que no hay guardado nada.
Líneas 8 a 10: Chequeamos si el último String del array es nulo, es decir está vacío.
Línea 11: Guardamos el valor “Quimica” en el último elemento del array “asignaturas”, donde antes estaba vacío.
Líneas 12 a 19: Recorremos ambos arrays dibujando los valores que contienen en pantalla.
- Si ejecutamos el programa, el resultado sería:
run:
La tercera asignatura no está definida todavía
Los estudiantes son:
1.- Pedro
2.- Antonio
3.- Lara
4.- Fabiola
5.- Pablo
Las asignaturas son:
1.- Matemáticas
2.- Lengua
3.- Quimica
BUILD SUCCESSFUL (total time: 0 seconds)
Arrays Multidimensionales
Los arrays multidimensionales son aquellos arrays en el que cada elemento es otro array. Para acceder a un elemento final del tipo declarado en el array, tendré que indicar los valores de todos los índices. Y tendremos tantos como dimensiones tenga el array.
Para crear un array multidimensional, emplearemos un par de corchetes por dimensión. Veámoslo en un ejemplo:
Actividad: Practicando con arrays multidimensionales
- Abre el compilador online:
- Introduce el siguiente código:
public class Actividad_ArrayMultidimensional {
public static void main(String[] args) {
String[] estudiantes ={"Pedro","Antonio","Lara","Fabiola","Pablo"};
String[] asignaturas;
int[][] notas;
asignaturas = new String[3];
asignaturas[0]="Matemáticas";
asignaturas[1]="Lengua";
asignaturas[2]="Quimica";
//definiendo las dimensiones del array multidimensional
notas = new int [asignaturas.length][estudiantes.length];
System.out.println ("número de filas = "+asignaturas.length);
System.out.println ("número de columnas = "+estudiantes.length);
//guardando valores en el array multidimensional
notas[0][0]=5;
notas[0][1]=2;
notas[0][2]=8;
notas[0][3]=7;
//accediendo a los valores almacenados
int fila = 1;
int columna = 2;
System.out.print("El estudiante "+estudiantes[columna-1]);
System.out.print(" ha obtenido una nota de "+notas[fila-1][columna-1]);
System.out.println(" en la asignatura "+asignaturas[fila-1]);
}
}
Línea 3: Declaración del array estudiantes. También lo inicializamos, asignando valores.
Línea 4: Declaración del array asignaturas.
Línea 5: Declaración del array multidimensional asignaturas.
Línea 6 a 9: Creación e inicialización del array asignaturas.
Línea 11: Creación del array multidimensional notas. Tiene dos dimensiones basadas en los anteriores arrays (estudiantes y asignaturas). En el array multidimensional notas, guardaremos las notas de los diferentes alumnos en las distintas asignaturas. La primera dimensión indica la asignatura y la segunda indica el estudiante.
Línea 15 a 18: Guardamos algunos valores en nuestro array multidimensional. Los valores para el resto de las combinaciones de los índices de las dimensiones, guardaran “0”, ya que el array es de tipo int.
Línea 20: Declaro e inicializo la variable “fila que usaré como primer índice del array notas.
Línea 21: Declaro e inicializo la variable “columna” que usaré como segundo índice del array notas.
Línea 22 a 24: Escribo en pantalla los valores de los diferentes arrays, para los índices empleados.
- Ejecutamos el programa, y el resultado sería:
run:
número de filas = 3
número de columnas = 5
El estudiante Antonio ha obtenido una nota de 2 en la asignatura Matemáticas
BUILD SUCCESSFUL (total time: 0 seconds)
NOTA:
Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.