unidimensionales
Un array es una colección de valores de un mismo tipo engrosados en la misma variable. De forma que se puede acceder a cada valor independientemente. Para Java además un array es un objeto que tiene propiedades que se pueden manipular.
Los arrays solucionan problemas concernientes al manejo de muchas variables que se refieren a datos similares. Por ejemplo si tuviéramos la necesidad de almacenar las notas de una clase con 18 alumnos, necesitaríamos 18 variables, con la tremenda lentitud de manejo que supone eso. Solamente calcular la nota media requeriría una tremenda línea de código. Almacenar las notas supondría al menos 18 líneas de código.
Gracias a los arrays se puede crear un conjunto de variables con el mismo nombre. La diferencia será que un número (índice del array) distinguirá a cada variable.
En el caso de las notas, se puede crear un array llamado notas, que representa a todas las notas de la clase. Para poner la nota del primer alumno se usaría notas[0], el segundo sería notas[1], etc. (los corchetes permiten especificar el índice en concreto del array).
La declaración de un array unidimensional se hace con esta sintaxis.
tipo nombre[];
Ejemplo:
double cuentas[]; //Declara un array que almacenará valores
// doubles
Declara un array de tipo double. Esta declaración indica para qué servirá el array, pero no reserva espacio en la RAM al no saberse todavía el tamaño del mismo.
Tras la declaración del array, se tiene que iniciar. Eso lo realiza el operador new, que es el que realmente crea el array indicando un tamaño. Cuando se usa new es cuando se reserva el espacio necesario en memoria. Un array no inicializado es un array null. Ejemplo:
int notas[]; //sería válido también INT[] NOTAS;
notas = new int[3]; //indica que el array constará de tres //valores de tipo int
//También se puede hacer todo a la vez
//INT notas[]=NEW INT[3];
En el ejemplo anterior se crea un array de tres enteros (con los tipos básicos se crea en memoria el array y se inicializan los valores, los números se inician a 0).
Los valores del array se asignan utilizando el índice del mismo entre corchetes:
notas[2]=8;
También se pueden asignar valores al array en la propia declaración:
int notas[] = {8, 7, 9};
int notas2[]= new int[] {8,7,9};//Equivalente a la anterior
Esto declara e inicializa un array de tres elementos. En el ejemplo lo que significa es que notas[0] vale 8, notas[1] vale 7 y notas[2] vale 9.
En Java (como en otros lenguajes) el primer elemento de un array es el cero. El primer elemento del array notas, es notas[0]. Se pueden declarar arrays a cualquier tipo de datos (enteros, booleanos, doubles, ... e incluso objetos).
La ventaja de usar arrays (volviendo al caso de las notas) es que gracias a un simple bucle for se puede rellenar o leer fácilmente todos los elementos de un array:
//Calcular la media de las 18 notas
suma=0;
for (int i=0;i<=17;i++){
suma+=nota[i];
}
media=suma/18;
A un array se le puede inicializar las veces que haga falta:
int notas[]=new notas[16];
...
notas=new notas[25];
Pero hay que tener en cuenta que el segundo new hace que se pierda el contenido anterior. Realmente un array es una referencia a valores que se almacenan en memoria mediante el operador new, si el operador new se utiliza en la misma referencia, el anterior contenido se queda sin referencia y, por lo tanto se pierde.
Un array se puede asignar a otro array (si son del mismo tipo):
int notas[];
int ejemplo[]=new int[18];
notas=ejemplo;
En el último punto, notas equivale a ejemplo. Esta asignación provoca que cualquier cambio en notas también cambie el array ejemplos. Es decir esta asignación anterior, no copia los valores del array, sino que notas y ejemplo son referencias al mismo array. Ejemplo:
int notas[]={3,3,3};
int ejemplo[]=notas;
ejemplo= notas;
ejemplo[0]=8;
System.out.println(notas[0]);//Escribirá el número 8
arrays multidimensionales
Los arrays además pueden tener varias dimensiones. Entonces se habla de arrays de arrays (arrays que contienen arrays) Ejemplo:
int notas[][];
notas es un array que contiene arrays de enteros
notas = new int[3][12];//notas está compuesto por 3 arrays //de 12 enteros cada uno
notas[0][0]=9;//el primer valor es 0
Puede haber más dimensiones incluso (notas[3][2][7]). Los arrays multidimensionales se pueden inicializar de forma más creativa incluso. Ejemplo:
int notas[][]=new int[5][];//Hay 5 arrays de enteros notas[0]=new int[100]; //El primer array es de 100 enteros notas[1]=new int[230]; //El segundo de 230
notas[2]=new int[400]; notas[3]=new int[100]; notas[4]=new int[200];
Hay que tener en cuenta que en el ejemplo anterior, notas[0] es un array de 100 enteros. Mientras que notas, es un array de 5 arrays de enteros.
Se pueden utilizar más de dos dimensiones si es necesario.
longitud de un array
Los arrays poseen un método que permite determinar cuánto mide un array. Se trata de length. Ejemplo (continuando del anterior):
System.out.println(notas.length); //Sale 5
System.out.println(notas[2].length); //Sale 400
La clase Arrays
En el paquete java.utils se encuentra una clase estática llamada Arrays. Una clase estática permite ser utilizada como si fuera un objeto (como ocurre con Math). Esta clase posee métodos muy interesantes para utilizar sobre arrays.
Su uso es
Arrays.método(argumentos);
fill
Permite rellenar todo un array unidimensional con un determinado valor. Sus argumentos son el array a rellenar y el valor deseado:
int valores[]=new int[23]; Arrays.fill(valores,-1);//Todo el array vale -1
También permite decidir desde que índice hasta qué índice rellenamos:
equals
Compara dos arrays y devuelve true si son iguales. Se consideran iguales si son del mismo tipo, tamaño y contienen los mismos valores.
sort
Permite ordenar un array en orden ascendente. Se pueden ordenar sólo una serie de elementos desde un determinado punto hasta un determinado punto.
int x[]={4,5,2,3,7,8,2,3,9,5};
Arrays.sort(x);//Estará ordenado
Arrays.sort(x,2,5);//Ordena del 2º al 4º elemento
binarySearch
Permite buscar un elemento de forma ultrarrápida en un array ordenado (en un array desordenado sus resultados son impredecibles). Devuelve el índice en el que está colocado el elemento. Ejemplo:
int x[]={1,2,3,4,5,6,7,8,9,10,11,12};
Arrays.sort(x);
System.out.println(Arrays.binarySearch(x,8));//Da 7
el método System.arraysCopy
La clase System también posee un método relacionado con los arrays, dicho método permite copiar un array en otro. Recibe cinco argumentos: el array que se copia, el índice desde que se empieza a copia en el origen, el array destino de la copia, el índice desde el que se copia en el destino, y el tamaño de la copia (número de elementos de la copia).
int uno[]={1,1,2};
int dos[]={3,3,3,3,3,3,3,3,3};
System.arraycopy(uno, 0, dos, 0, uno.length);
for (int i=0;i<=8;i++){
System.out.print(dos[i]+" ");
} //Sale 112333333
