====== Estructuras de datos: 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 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.
{{ :bloque2:arrays.png?300 |}}

===== Declarar una variable de tipo array =====
Las variables de tipo array se declaran así:
<code java>
   tipo_de_dato[] identificador;
   
   //Ejemplos
   int[] numerosEnteros;
   double[] numerosReales;
   String[] listaCadenas;
</code>
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__. 

===== Crear un objeto array =====
Para construir un array, igual que ocurre con casi todos los objetos, necesitamos invocar al operador **//new//**:
<code java>
int[] enteros = new int[4];           //array con capacidad para 4 enteros (int)

String[] listaCadenas;
listaCadenas = new String[200];       //array con capacidad para 200 Strings    

</code>

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

<code java>
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
</code>

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

==== Contenido por defecto de un 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''

<code java>
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
</code>
===== 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.
<code java>
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])
</code>

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

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

====== 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.**

<code java>
//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
*/
</code>

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

<code java>
//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
}
</code>

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

<code java>
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)
</code>

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 como un conjunto de filas y columnas:

<code java>
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}};
</code>

==== Acceder a las posiciones de una matriz ====
Debo utilizar tantos índices como dimensiones tenga el array:
<code java>
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
}
</code>

----

{{ vimeo>306802923?medium }}

----
===== 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 ayudan a trabajar con arrays: [[bloque2:clasearrays|Clase Arrays]].


----
(c) {{date> %Y}} Fernando Valdeón