Un array es un objeto que nos permite guardar varios elementos de un mismo tipo. Un array puede guardar valores de tipo primitivo o de tipo de referencia, pero el array siempre será un objeto y como tal se almacena en la memoria dinámica, el Heap.
Los arrays pueden ser unidimensionales (vectores) o multidimensionales (matrices).
En la imagen superior tenemos un ejemplo de un array unidimensional de longitud n. El índice de los arrays en Java siempre empiezan en 0, por tanto la última posición será n-1. El índice nos permite acceder a un elemento determinado del array.
En los arrays multidimensionales tendremos tantos índices como dimensiones.
Declaración de un array
Un array se declara especificando el tipo del array a la variable:
char[] arrayCaracteres;
char arrayVocales []; //posición de los corchetes legal pero menos legible.
String[] arrayCadenas;
int[] cuponOnce;
int[][] matriz;
La declaración del array crea una referencia que apuntará al array.
La declaración nunca debe indicar el tamaño del array.
Creación de un array
arrayCaracteres = new char[20];
arrayVocales = new char[5];
arrayCadenas = new String[3];
Después de su creación los arrays se inicializan con el valor predeterminado de su tipo.
Aunque hemos separado la declaración de la construcción del array, lo más usual es que la declaración y la construcción se hagan en una misma línea:
int[] notasTrimestres = new int[4];
Java también permite utilizar una forma abreviada para crear arrays con valores iniciales dando los valores entre llaves:
char[] letras = {‘a’, ‘b’, ‘c’, ‘d’};
String[] nombres = {“María”, “Jose”, “Alberto”}
Arrays multidimensionales
Dado que es posible declarar un array de cualquier tipo, los arrays multidimensionales en Java se crean mediante arrays de arrays.
Un array bidimensional:
//Crea un array de tres elementos en los que cada uno de ellos es un array.
int [][] bidimensional = new int [3][];
Ahora podemos dar a cada uno de estos tres arrays dimensiones diferentes si queremos:
bidimensional[0] = new int[2];
bidimensional[1] = new int[3];
bidimensional[2] = new int[2];
Si todos nuestros arrays de arrays van a tener la misma dimensión podemos ahorrarnos esfuerzo y se permite la siguiente declaración y construcción:
int [][] rectangular = new int[3][2]
Límites
En Java todos los arrays comienzan en 0. El número de elementos de un array se guarda en el atributo del array length. Es recomendable utilizar este atributo cuando iteremos los elementos de un array para evitarnos acceder fuera de los límites permitidos.
Si intentamos acceder a una posición incorrecta del array se generará la excepción ArrayIndexOutOfBoundsException.
Dando Valores a un Array
Podemos rellenar los arrays dando valor a cada uno de sus elementos:
public class Persona {
private String nombre;
private int edad;
//... // Constructores, getters, setters
public static void main (String[] args){
Persona[] familia = new Persona[3];
Persona[0] = new Persona("Maria", 35);
Persona[1] = new Persona("Jose", 30);
Persona[2] = new Persona("Ana", 3);
}
}
O bien utilizando un bucle:
public class Persona{
private String nombre;
private int edad;
//...// Constructores, getters, setters
public static void main (String[] args){
String[] nombres = {"Maria", "Jose", "Ana"};
int[] edades = {35, 30, 3};
Persona[] familia = new Persona[3];
for (int i = 0; i< familia.length; i++){
Persona[i] = new Persona(nombres[i], edades[i]);
}
}
}
Asignaciones Legales en Arrays
De tipos primitivos:
Se puede asignar a una posición del array cualquier variable que pueda ser promovidos o convertidos al tipo del array.
Por ejemplo, en un array de enteros podemos incluir shorts, bytes, chars …
public class asignaArray{
public static void main(String[] args){
byte a = 3;
short b = 30000;
int c = 450;
long d = 300000L;
float e = 2500.203F;
double f = 3234.25;
char g = 'B';
int [] enteros = new int[10];
enteros[0] = a;
enteros[1] = b;
enteros[2] = c;
enteros[3] = (int) d;
enteros[4] = (int) e;v
enteros[5] = (int) f;
enteros[6] = g;
enteros[7] = c/a;
enteros[8] = (int) d/a;
enteros[9] = (int) e/a;
for (int i = 0; i< enteros.length; i ++){
System.out.println("enteros["+ i + "]: " + enteros[i]);
}
}
}
De tipos de referencia: Se puede asignar cualquier subclase del tipo. Y si el tipo del array es una interfaz podemos asignar cualquier objeto que implemente dicha interfaz.
Por ejemplo, podríamos tener un array de Empleado con distintos tipos de empleado:
Empleado[] empleados = new Empleado[4];
empleados[0]=new Tecnico();
empleados[1]=new Secretario();
empleados[2]=new Contable();
empleados[3]=new Tecnico();
for (int i=0; i< empleados.length; i++){
Empleado e = empleados[i];
System.out.println(e.getNombre());
System.out.println(e.getAntiguedad());
System.out.println(e.getSueldo());
}
Es incluso posible hacer una colección con objetos de cualquier clase, ya que en Java todos los objetos heredan de Object:
Object [] objetos = new Object[5];
objetos[0] = new Empleado();
objetos[1] = new Batman();
objetos[2] = new Libro();
objetos[3] = new String("Maria");
objetos[4] = new Bicicleta();