FRANCISCA PIZARRO SUAREZ

LA CLASE ARRAY
Un array o matriz es simplemente una variable que puede contener valores múltiples, a
diferencia de una variable regular que solo puede contener un único valor.

Los siguientes son algunos puntos importantes acerca de las matrices, arreglos o arrays de
Java.

 En Java, todas las matrices se asignan dinámicamente.

 Como las matrices/arrays son objetos en Java, cada array tiene asociado una variable
de instancia de longitud (length) que contiene la cantidad de elementos que la matriz
puede contener. (En otras palabras, length contiene el tamaño de la matriz.)
 Un array en Java se declara con corchetes [] después del tipo de datos.
 Los datos en el array están ordenados y cada uno tiene un índice que comienza
desde 0.
 El array Java también se puede usar como un campo estático, una variable local o un
parámetro de método.
 El tamaño de un array debe especificarse mediante un valor int y no, long o short.

1. Qué es un Array en Java

Una array o matriz es una colección de variables del mismo tipo, a la que se hace
referencia por un nombre común. En Java, los arrays pueden tener una o más dimensiones,
aunque el array unidimensional es el más común.

2. Arrays unidimensionales

Un array unidimensional es una lista de valores relacionados. Aglutinan datos del mismo tipo.

Un índice encerrado entre corchetes nos permite acceder a cada elemento

Cómo declarar un array:

tipo nombreArray[];

tipo[] nombreArray;

1
FRANCISCA PIZARRO SUAREZ

La declaración de un array tiene dos componentes: el tipo y el nombre.

// ambas son declaraciones válidas

int intArray[];
int[] intArray;

//Tipo de datos primitivos

byte byteArray[];
short shortArray[];
boolean booleanArray[];
long longArray[];
float floatArray[];
double doubleArray[];
char charArray[];

Aunque la primera declaración anterior establece el hecho de que intArray es una variable de
matriz, en realidad no existe una matriz. Simplemente le dice al compilador que la variable
(intArray) contendrá una matriz de tipo entero. Para vincular intArray con una matriz física real
de enteros, debe asignar una usando new y asignarlo a intArray.

Instanciando un array en Java (ahora realmente se le asigna memoria al array)

Nombre_array = new tipo [tamaño];

 tipo especifica el tipo de datos que se asignará

 tamaño especifica el número de elementos en el array
 nombre-array es el nombre de la variable del array vinculado al mismo.
 Es decir, para usar new para asignar un array, debe especificar el tipo y la cantidad
de elementos a asignar.

Ejemplo:

int intArray[]; //declarando un array

intArray = new int[20]; // asignando memoria al array

int[] intArray = new int[20]; // combinando ambas declaraciones en una

int intArray[] = new int[20]; // combinando ambas declaraciones en una

Ejemplo de inicialización de un array:

2
FRANCISCA PIZARRO SUAREZ

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 ambas operaciones en la misma instrucción:

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

Al crear un array de esta forma, Java asigna valores por defecto a sus elementos:

 0 si son números enteros o reales.

 '\u0000' si son caracteres.

 false si son datos lógicos.

 null si son objetos.

Los valores del array se asignan utilizando el índice del mismo entre corchetes:
notas[0]=8;
notas[1]=7;
notas[2]=9;

También se pueden asignar valores al array en la propia declaración:

int[] notas2 = {8, 7, 9};

int[] notas3= 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.

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.
De hecho elimina ese contenido.

Un array se puede asignar a otro array (si son del mismo tipo):

3
FRANCISCA PIZARRO SUAREZ

int a[];
int b[]=new int[]{3,4,5,6,7,8};
a=b;

Accediendo a los elementos del Array

Podemos recorrer un array y acceder a sus elementos utilizando el bucle for.

//acceder a los elementos del array

for (int i = 0; i < arr.length; i++){

System.out.println("Elemento en el índice " + i + " : "+ arr[i]);

for…each

En las últimas versiones de Java se introdujo una nueva forma de uso del for, a la que se
denomina “for extendido” o “for each”. Esta forma de uso del for, que ya existía en otros
lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el
número de elementos a recorrer.

La sintaxis que se emplea es:

for (TipoBase variable: ArrayDeTiposBase) {..}

for(int elemento:arr){

System.out.println("Elemento en :" + elemento);

4
FRANCISCA PIZARRO SUAREZ

Métodos de la clase Array.

https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

Los métodos de la clase Array se encuentran en el paquete java.util.Arrays, este paquete hay
que importarlo.

import java.util.Arrays;

Class Arrays
java.lang.object

|------ java.util.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), es decir que para utilizar
sus métodos hay que utilizar simplemente esta sintaxis:

Arrays.método(argumentos);

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. A diferencia del operador de
igualdad (==), este operador sí compara el contenido. Ejemplo (comparación entre el
operador de igualdad y el método equals):

int[] a= {2,3,4,5,6};
int[] b= {2,3,4,5,6};
int[] c=a;
System.out.println(a==b); //false
System.out.println(Arrays.equals(a,b)); //true
System.out.println(a==c); //true
System.out.println(Arrays.equals(a,c)); //true

sort
Permite ordenar un array en orden ascendente. Se pueden ordenar todo el array o bien
desde un elemento a otro:

int[] x={4,5,2,3,7,8,2,3,9,5};
Arrays.sort(x,2,5); //El array queda {4 5 2 3 7 8 2 3 9 5} se incluyen los indices
Arrays.sort(x); //Estará completamente ordenado

5
FRANCISCA PIZARRO SUAREZ

sort ordena de forma ascendente (de menor a mayor). Para ordenar un array de forma
descendente (de mayor a menor) hay que indicarlo utilizando el método reverseOrder() de la
clase Collections.

Para utilizar reverseOrder es necesario incluir el import:

import java.util.Collections;

Por ejemplo, para ordenar el array nombres de forma descendente escribimos la instrucción
Arrays.sort de la siguiente forma:

Arrays.sort(nombres, Collections.reverseOrder());

También tenemos la opción de ordenar sólo una parte del array, indicando la posición del
elemento inicial y la del elemento final (que no se incluye en la ordenación).

Con Arrays.sort podemos ordenar arrays de cualquier tipo de datos. Por ejemplo, para ordenar
un array de enteros:

int [] numeros = {3, 5, 1, 2, 1, 7, 0, -1};

Arrays.sort(numeros);

//mostrarlo ordenado

for (int n : numeros) {

System.out.println(n);

Collections.reverOrder() sólo funciona para arrays de objetos.

Por este motivo si queremos ordenar de forma descendente arrays de tipos de datos simples
debemos utilizar la clase envolvente equivalente al tipo de dato básico. Puedes ver las clases
envolventes que corresponden a cada tipo de dato en esta entrada.

Por ejemplo, para ordenar un array de enteros de forma descendente hay que declararlo de
tipo Integer en lugar de int.

Integer [] numeros = {3, 5, 1, 2, 1, 7, 0, -1};

Arrays.sort(numeros, Collections.reverseOrder());

for (int n : numeros) {

System.out.println(n);

6
FRANCISCA PIZARRO SUAREZ

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)); //Escribe: 7

copyOf
Obtiene una copia de un array. Recibe dos parámetros: el primero es el array a copiar y
el segundo el tamaño que tendrá el array resultante.
De modo que:
 Si el tamaño es menor que el del array original, sólo obtiene copia de los
primeros elementos (tantos como indique el tamaño).

 Si el tamaño es mayor que el original, devuelve un array en el que los

elementos que superan al original se rellenan con ceros o con datos de tipo
null (dependiendo del tipo de datos del array.

int[] a = {1,2,3,4,5,6,7,8,9};
int[] b=Arrays.copyOf(a, a.length); //b es {1,2,3,4,5,6,7,8,9}
int[] c=Arrays.copyOf(a, 12); //c es {1,2,3,4,5,6,7,8,9,0,0,0}
int[] d=Arrays.copyOf(a, 3); //d es {1,2,3}

copyOfRange
Funciona como la anterior, sólo que indica con dos números de qué elemento a qué
elemento se hace la copia:

int[] a = {1,2,3,4,5,6,7,8,9};
int []b=Arrays.copyOfRange(a, 3,6); //b vale {4,5,6}

fill
Permite rellenar todo un array unidimensional con un determinado valor. Sus
argumentos son el array a rellenar y el valor deseado:

int[] a=new int[23];

Arrays.fill(valores,-1); //Todo el array vale -1
También permite decidir desde que índice hasta qué índice rellenamos:

7
FRANCISCA PIZARRO SUAREZ

Arrays.fill(valores,5,8,-1); //Del elemento 5 al 7 valdrán -1

DATO
NOMBRE DESCRIPCIÓN PARÁMETROS
DEVUELTO

binarySearch Busca un valor que le pasamos Un array y un valor. Los dos del mismo tipo. int
por parámetro, devuelve su Estos pueden ser un byte, char, double, float,
posición. Debe estar ordenado. int, long, short u objecto.

copyOf Copia un array y lo devuelve
en un nuevo array.
Un array y la longitud. Si se pasa del tamaño array del mismo
del array original, rellena los con ceros las tipo que se
posiciones sobrantes. Estos pueden ser un introduce
byte, char, double, float, int, long, short u
objecto.

copyOfRange Copia un array y lo devuelve Un array, posición origen y destino. Estos array del mismo
en un nuevo array. Le pueden ser un byte, char, double, float, int, tipo que se
indicamos la posición de origen long, short u objecto. introduce.
y de destino.

equals Indica si dos arrays son Dos arrays del mismo tipo. true o false
iguales.

fill Rellena un array con un valor Un array y el valor a rellenar. Estos pueden ser No devuelve nada
que le indiquemos como un byte, char, double, float, int, long, short u
parámetro. objecto.

sort Ordena el array. Un array. No devuelve nada

Estos pueden ser un byte, char, double, float,
int, long, short u objecto.

toString Muestra el contenido del array Un array. Estos pueden ser un byte, char, Devuelve una
pasado como parámetros double, float, int, long, short u objecto. cadena con el
contenido del
array.

8
FRANCISCA PIZARRO SUAREZ