Arrays

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 creados siempre tienen la misma cantidad de elementos; no pueden crecer. En Java los arrays son objetos al igual que el resto de tipos de datos que veremos a partir de ahora y funcionan algo distinta a los tipos primitivos.

Declarar una variable

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á. Puede almacenar cualquier tamaño de array.

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

Crear un objeto array

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. Habría que crear otro array.

Acceder al contenido del array

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] + " ");   
}

Lo más importante de los arrays

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 9
//enteros1 -> @F456AC y enteros2 -> @F456AC
//Ambas variables referencian al mismo array
//Desde ambas modifico el mismo array

Métodos con arrays

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){
   String[] cadenas = new String[cantidad];    //Creo un array de Strings
 
   Scanner input = new Scanner(System.in);
   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.

Dimensión de un array

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

Arrays bidimensionales (Matrices)

Las matrices son arrays que tienen 2 dimensiones. Se pueden entender imaginar las filas y las columnas:

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

Acceder a las posiciones

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;
 
//Leyendo desde teclado
for(int i = 0; i < matriz.length; i++){
   for(int j = 0; j< matriz[0].length; j++){
      System.out.println("Introduce un entero");
      matriz[i][j] = input.nextInt();
   }
}
 
//O mediante 2 bucles, mostrandola por filas/columnas
for(int i = 0; i < matriz.length; i++){
   for(int j = 0; j< matriz[0].length; j++){
      System.out.print(matriz[i][j] + " ");
   }
   System.out.println();  //Salto de linea
}

Clase Arrays

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 ayuda a trabajar con arrays. Para saber qué métodos nos ofrece esta clase podemos consultar la API de Java: https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

Algunos de estos métodos estáticos son:

Método	Descripción	Parámetros que recibe	Tipo de datos que devuelve
boolean equals(array1, array2)	Indica si el contenido de ambos arrays es el mismo	Dos arrays del mismo tipo	true si son iguales, false en caso contrario
String toString(array)	Devuelve un String con la representación del contenido del array	Un array unidimensional de cualquier tipo	Un String con la representación
void fill(array, valor)	Rellena el array con el valor indicado	Un array de cualquier dimensión y un valor del mismo tipo	No devuelve nada
tipo[] copyOf(array);	Devuelve otro array que es una copia del indicado	Un array unidimensional	Un array del mismo tipo que contiene lo mismo que el indicado
tipo[] copyOfRange(array, inicio, fin)	Devuelve otro array que es una copia del indicado desde el indice inicio hasta el índice fin	Un array unidimensional y dos enteros indicando el rango	Un array del mismo tipo que contiene una copia del rango indicado
int binarySearch(array , valor)	Busca un valor dentro de un array del tipo de valor (El array debe estar ordenado)	Un array y un valor del mismo tipo de datos	int con la posición en la que lo encuentra, o -1 si no.
void sort(array)	Ordena el array. Los tipos que contiene deben ser ordenables (primitivos, u objetos con compereTo()	Un array unidimensional de cualquier tipo	No devuelve nada

//Compruebo si los arrays contienen lo mismo
if(Arrays.equals(enteros1, enteros2)){
   System.out.println("Contienen los mismos valores");
}
 
//Copio el array enteros1 y guardo la referencia en la variable copiaEnteros
int[] copiaEnteros = Arrays.copy(enteros1);
 
//Relleno la matriz con el caracter '*'
char[][] caracteres = new char[50][100];
Arrays.fill(caracteres, '*');
 
//Muestro por pantalla una representacion del array
int[] numeros = {-4, 6, 0, -34};
System.out.println(Arrays.toString(numeros));