(OCA Objectives 4.1 and 4.2)

Los arrays son objetos Java que almacenan múltiples variables del mismo tipo. Los arrays pueden almacenar primitivos o referencias a objetos, pero el propio array siempre será un objeto en el Heap, incluso si el array declarado contiene elementos primitivos. En otras palabras, no existe un array primitivo, pero tu puedes hacer un array de primitivos. Para este apartado, tu necesitas saber tres cosas:

• Como crear un array de variables de referencia (declarar)
• Como crear un array (constructor)
• Como inicializar un array con elementos (inicialización)

Declarando un Array

Los arrays son declarados comenzando con el tipo de elementos que contendrá, pueden ser objetos o primitivos, seguido de corchetes [] a la izquierda o a la derecha del identificador del array, ejemplos:

int [] identificador1;  // Recommended
int identificador2 []; // Legal but less readable
Thread [] threads;  // Recommended
Thread threads [];  // Legal but less readable
String [][][] matrix3D;  // recommended
String [] matrix2D [];  // yucky, but legal

NUNCA se debe incluir el tamaño del array en su declaración:

!!MAL¡¡ java int[5] arr;

Inicializando un array

Inicilizar un array significa poner "cosas" en el. Estas "cosas" son los elementos del array, y pueden ser elementos primitivos u objetos referenciados por variables de referencia. Si tu tienes un array de objetos, el array no contiene actualmente objetos, el array contiene referencias a objetos. Si dichas referencias no tienen un objeto asignado, estas tienen null como valor. Los elementos individualmente puede ser accedidos a partir de un indice numérico (siendo el primero 0). Inicialización de ejemplo:

int[ ][ ] myArray = new int[3][ ];
myArray[0] = new int[2];
myArray[0][0] = 6;
myArray[0][1] = 7;
myArray[1] = new int[3];
myArray[1][0] = 9;
myArray[1][1] = 8;
myArray[1][2] = 5;

##Inicializando los elementos en un bucle

Los arrays tiene una única variable publica, length, que contiene el numero de elementos en el array, esta variable nos indica la capacidad del array y no quiere decir que todos sus elementos estén inicializados. Con ella podemos recorrerlo a través de todos sus elementos:

Dog[] myDogs = new Dog[6]; // creates an array of 6 Dog references
for(int x = 0; x < myDogs.length; x++) {
    myDogs[x] = new Dog(); // assign a new Dog to index position x
}

Declaración, construcción e inicialización en una linea.

int x = 9;
int[] dots = {6,x,8};

Para arrays multidimensionales:

int[][] scores = {{5,2,4,7}, {9,2}, {3,4}}

El código anterior crear cuatro objetos en el Heap, un array de int que se asigna a scores y los tres restante arrays que se declaran dentro de dicho array.

Construcción e inicialización de un array anónimo.

Un array anónimo es aquel que se construye e inicializa y posteriormente se asigna a una variable de referencia. Se conoce como anónimo porque no se necesita asignar el nuevo array a nada. Y cuando usar? just-in-time. Ejemplo:

public class JIT {
  void takesAnArray(int[] someArray) {
    // use the array parameter
  }
  public static void main (String [] args) {
    JIT j = new JIT();
    j.takesAnArray(new int[] {7,7,8,2,5});   // pass an array created just-in-time
 }
}

Recuerda que en la creación de un array anónimo no se necesita especificar el tamaño de este, dicho tamaño vendrá determinado por el numero de elementos con los que cuenta.

##Asignaciones correctas de elementos en un array.

Array de primitivos

Los arrays de primitivos aceptan cualquier tipo de dato siempre y cuando puedan ser cambiados con un casting implícito. Por ejemplo, para un array de int, se pueden insertan valores de tamaño de 32 bits:

int[] weightList = new int[5];
byte b = 4;
char c = 'c';
short s = 7;
weightList[0] = b;  // OK, byte is smaller than int
weightList[1] = c;  // OK, char is smaller than int
weightList[2] = s;  // OK, short is smaller than int

Array de referencias de objetos

Si el tipo de array declarado es una clase, se permite añadir objetos del mismo tipo que el declarado y de cualquier subclase de este. Si el array declarado es de un tipo de interfaz, los elementos del array pueden referenciar a cualquier instancia de cualquier clase que implemente la interfaz declarada.

En otras palabras, un array de objetos puede contener cualquier tipo que pase el test IS-A con el tipo de array declarado.

Asignaciones de array para arrays de una dimensión.

Un array de tipo primitivo solo puede ser asignado a otro array que sea compatible con el tipo del array declarado, por ejemplo:

int[] splats;
int[] dats = new int[4];
char[] letters = new char[5];
splats = dats;    // OK, dats refers to an int array
splats = letters; // NOT OK, letters refers to a char array

Al contrario de los arrays declarados de cualquier tipo de clase, en estos se permite el asignar arrays de sublclases a arrays del tipo de la clase superior:

Number[] numero;
Integer[] enteros= new Integer[5];
numero= enteros;   // OK because Integer is a type of Number
String[] cadenas = new String[99];
numero= cadenas ;      // NOT OK, Stringis not a type of Number

Asignaciones de array para arrays multidimensionales

Cuando se asigna un array a una referencia declarada previamente, el array que se asigna debe de tener las mismas dimensionas que el array al que se asigna.

int[] blots;
int[][] squeegees = new int[3][];
blots = squeegees;         // NOT OK, squeegees is a two-d array of int arrays
int[] blocks = new int[6];
blots = blocks;            // OK, blocks is an int array