Un array es una estructura de datos que almacena una cantidad fija de elementos de la misma clase o tipo. Todos los datos que almacena deben ser del mismo tipo. Una vez creado el array siempre tiene la misma cantidad de elementos; no pueden crecer.

En Java, los arrays son objetos al igual que los tipos String, Scanner y el resto de tipos de datos que veremos a partir de ahora. Los objetos funcionan de forma distinta a los tipos primitivos.

Las variables de tipo array se declaran así:

   tipo_de_dato[] identificador;
 
   //Ejemplos
   int[] numerosEnteros;
   double[] numerosReales;
   String[] listaCadenas;

Cuando creamos una variable de tipo array no indicamos el tamaño que almacenará, solo el tipo de los datos que contendrá. La variable puede almacenar un array de cualquier tamaño.

Las variables anteriores no podré usarlas hasta que no contengan la referencia de un array. Las variables de tipos de datos que almacenan objetos (no tipos primitivos) se llaman variables de referencia.

Para construir un array, igual que ocurre con casi todos los objetos, necesitamos invocar al operador new:

int[] enteros = new int[4];           //array con capacidad para 4 enteros (int)
 
String[] listaCadenas;
listaCadenas = new String[200];       //array con capacidad para 200 Strings

También puedo crear un array en el momento de la declaración de su variable, indicando directamente los valores que contiene (luego podrán ser modificados):

int[] numeros = {4, 6, -435, 65, 0};           //He construido un array de 5 enteros
 
String[] nombres = {"Juan", "Pedro", "", "Maria"};   //He construido un array de 4 Strings

Una vez que indico el tamaño de un array, dicho tamaño no puede ser modificado. Si quiero tener otro tamaño, debo crear otro array.

Cuando construimos un array, todas sus celdas se inicializan a un valor por defecto:

• Arrays de tipo primitivo (int, char, boolean double, etc): Todas sus celdas se inicializan a 0, ó a false si es boolean
• Arrays de tipo objeto (String, Scanner o cualquier otra clase): Todas sus celdas se inicializan a null

double[] array = new double[4]; -> sus celdas contienen el valor 0.0
boolean[] array2 = new boolean[3]; -> sus celdas contiene el valor false
 
String[] array3 = new String[3]; -> sus celdas contiene el valor null

Accedemos a cada posición del array mediante un índice que comienza en 0 y va hasta la longitud -1 del array.

int[] enteros = new int[4];    //Array con tamaño para 4 enteros
 
enteros[0] = 23;
enteros[1] = -3;
enteros[2] = 2;
enteros[3] = 0;
 
System.out.println("La posición 0 contiene: " + enteros[0])
System.out.println("La posición 1 contiene: " + enteros[1])
System.out.println("La posición 2 contiene: " + enteros[2])
System.out.println("La posición 3 contiene: " + enteros[3])

Para conocer en todo momento en tamaño que tiene un array tenemos la propiedad length. Así puedo recorrerlo con un bucle for.

//Almacenar datos desde teclado
for(int i = 0; i < enteros.length; i++){
  System.out.println("Introduce un número"); 
  enteros[i] = input.nextInt();
}
 
//Mostrarlo por consola en una misma linea
for(int i = 0; i < enteros.length; i++){
   System.out.print(enteros[i] + " ");   
}

El aspecto más importante de los arrays es que son objetos y no tipos primitivos. Toda variable que no es de un tipo primitivo es una variable de referencia. Solo hay 8 tipos primitivos (byte, short, int, long, float, double, boolean, char). Todo los demás son objetos.

Las variables de referencia no almacenan al objeto (valor) sino la referencia (dirección de memoria) de ese objeto.

//Con variables primitivas
int num1 = 7;
int num2;
 
num2 = num1;
num2 = 4;
//En este punto num1 -> 7 y num2 -> 4
 
//Con variables de referencia: creo 2 variables, pero solo un array
int[] enteros1 = new int[4];
int[] enteros2;
 
enteros2 = enteros1;
//Ambas variables tienen la misma información:
//Y es la referencia (dirección) a un mismo array. Por ej: @F456AC
 
enteros1[0] = 6;
enteros2[0] = 9;
 
/*
- Tanto enteros1[0] como enteros2[0] guardan el valor int 9
- System.out.println(enteros1) -> @F456AC y System.out.println(enteros2) -> @F456AC
- Ambas variables referencian al mismo array y desde ambas variables accedo al mismo array
*/

Como cualquier otro tipo de datos, los métodos pueden recibir arrays como parámetros o devolverlos como valor de retorno.

//Método que recibe una referencia a un array
static void mostrarArrayEnteros(int[] array){
   for(int i = 0; i < array.length; i++){
      System.out.print(array[i] + " ");   
}
 
//Método que devuelve una referencia a un array
//Recibe un int que indica la cantidad de Strings que pido al usuario
static String[] pedirCadenas(int cantidad){
   Scanner input = new Scanner(System.in);
 
   String[] cadenas = new String[cantidad];    //Creo un array de Strings
 
   for(int i = 0; i < cantidad; i++){
      System.out.println("Introduce una cadena");
      cadenas[i] = input.nextLine();
   }
   input.close();
 
   return cadenas;   //Devuelvo la referencia al array creado en memoria
}

Si un método recibe un array y lo modifica, el array quedará modificado para todas las variables del programa que contengan la misma referencia.

Un array puede tener todas las dimensiones que se desee. Entendemos la dimensión como el tipo de datos de la variable. Una variable de tipo int[] no puede referenciar un array de tipo int[][].

int[][] = new int[2][4];     //Array con capacidad para 8 enteros (2 dimesiones)
char[][][][] = new char[2][3][2][5];   //Array con capacidad para 2x3x4x5 caracteres (4 dimensiones)

Los más comunes son los arrays de una dimensión o de dos dimensiones (matrices).

Las matrices son arrays que tienen 2 dimensiones. Se pueden entender como un conjunto de filas y columnas:

char[][] matrizCaracteres;   //Declaro la variable de referencia
 
matrizCaracteres = new char[2][3];  //Creo un array indicando el tamaño de sus dimensiones
 
int[][] numeros = {{2, 4}, {5, 6}, {-7, -2}};

Debo utilizar tantos índices como dimensiones tenga el array:

int[][] matriz = new int[2][3];    //Matriz de enteros de 2x3
 
matriz[0][0] = 2;
matriz[0][1] = 4;
matriz[0][2] = 4;
matriz[1][0] = 6;
matriz[1][1] = 6;
matriz[1][2] = 9;
 
//Por lo que uso 2 bucles para recorrerlo (guardando datos)
for(int i = 0; i < matriz.length; i++){
   for(int j = 0; j< matriz[i].length; j++){
      System.out.println("Introduce un entero");
      matriz[i][j] = input.nextInt();
   }
}
 
//Dos bucles para mostrar sus datos, mostrándolos por filas/columnas
for(int i = 0; i < matriz.length; i++){
   for(int j = 0; j< matriz[i].length; j++){
      System.out.print(matriz[i][j] + " ");
   }
   System.out.println();  //Salto de linea
}

Los arrays, aunque son objetos, no se crean a partir de una clase. Sin embargo tenemos una clase que contiene una serie de métodos estáticos que nos ayudan a trabajar con arrays: Clase Arrays.

© 2024 Fernando Valdeón