Programación

Tema 4. Estructuras estáticas de datos:Arrays

Ciclo Formativo Grado Superior:

Desarrollo de Aplicaciones Web

Curso 2020-2021
Contenidos

• Definición, declaración y creación de arrays.

• Ordenamiento de arrays. Algoritmos.
• Arrays multidimensionales.
¿Qué es un array?
Es una estructura de datos que almacena una cantidad fija de
elementos del mismo tipo, a los cuales se puede acceder por medio
de un índice que indica su posición dentro de la estructura.

• Estructura homogénea de datos

→ Todos los datos son de un mismo tipo o clase.

• Estructura estática de datos:

→ Los arrays contienen siempre el mismo número de datos

• En álgebra: vectores (1D), matrices (2D), tensores (3D).

• En Java: Son objetos que se declaran, crean, inicializan y consultan.

 Declaración de arrays en Java (I)
Declaración de un array en Java:
Tipo_de_los_elementos [] nombre_de_referencia_al_array

O equivalentemente:
Tipo_de_los_elementos nombre_de_referencia_al_array [];

Ejemplos:
int [] arrayDeEnteros; int arrayDeEnteros [];
char [] arrayDeCaracteres; char arrayDeCaracteres [];

En la declaración no se especifica el tamaño del array.

¿Por qué? → Porque en la declaración no se crea el array, sino la referencia
que lo apunta.
De hecho, lo que realmente estamos declarando es una referencia al array.
Declaración de arrays en Java (II)
Declaración de arrays:
int [] arrayD eEnteros;
cha r [] array DeCaracter es;
¡Ojo!: Estos ejemplos declaran una
referencia al array
Todavía no tengo ningún array, sino algo
que puede apuntar (referirse) a un array.

Los arrays en Java son objetos y a los objetos en Java no se accede

nunca de forma directa, sino a través de referencias.

La declaración int [] serie; significa que:

Obtengo una referencia llamada serie que puede apuntar a un array de enteros,
pero de momento, dependiendo de dónde se declare (se verá en tema Métodos):
→ o bien no apunta a nada
→ o bien apunta a algo indefinido

Para que serie apunte a un array debemos crear dicho array.

Creación de arrays en Java (I)
Crear un array es asignarle un espacio de almacenamiento en
memoria.
Para ello, hay que usar el operador new, seguido por:
• El tipo de los elementos del array y
• El número de elementos que va a contener entre corchetes
new t ipo_ele mento [ n_eleme ntos]

El operador new crea un array de n_elementos del tipo tipo_elemento

y devuelve una referencia al mismo.

La creación del array fija su número de elementos, que permanece

inmutable:
new int[5]; // Crea un array de 5 enteros
// y devuelve una referencia al mismo.
 Creación de arrays en Java (II)
Obviamente, de poco nos sirve crear un array si no podemos referirnos a él.

→ ¿Cómo lo usamos? Asignando la referencia que devuelve new a

una referencia a un array.
in t serie [];
se rie = n ew int[ 5];

Celdas Posiciones del array

serie
0
Esto es la referencia Los elementos del
1
array ocupan
2 posiciones de
3 memoria contiguas.
Referencia al array.
4
¡Ojo!, serie es el
nombre de la “flecha”. Esto es el objeto
array
Creación de arrays en Java (III)

Los arrays se pueden declarar y crear simultáneamente:

int [ ] serie = new int[5];

Se pueden declarar y crear varios arrays que contengan el mismo tipo

de elementos en una sola línea:
int a [] = ne w int[2 0], b[] = new int[100 ];
De Objetos y Referencias (I)
• A los objetos se accede mediante referencias que apuntan a los mismos.

• Los arrays en Java son objetos.

Una referencia es a un objeto lo que la dirección a un domicilio.

La dirección de tu casa  Tu Casa
Refere ncia  Objeto
Obviamente son conceptos relacionados. Una carta no llega a su
destino si no pones bien las señas.

• Veamos qué significa esto en el ámbito de los arrays.

 De Objetos y Referencias (II)
1 int [] serie1 = new int[5];
2 int [] serie2 = new int[3];
3 serie1 = serie2;

serie1 serie1 seri e2

1
2

ser ie2 serie1

Objeto no apuntado por
ninguna referencia.
3 Objeto apuntado por
En Java es borrado de la dos referencias.
memoria.
La imagen anterior trata de explicar el funcionamiento del operador new (no solo para los arrays). Utilizar
dos veces el operador new con la misma referencia de array, provoca que haya valores que se quedan
sin referencia. A eso se le suele llamar basura digital, es espacio que se consume en la memoria y que
no se puede utilizar.
En Java un recolector de basura se encarga cada cierto tiempo de eliminar la basura (a diferencia de
lo que ocurre en lenguajes menos seguros como C).
Desde el código podemos forzar la recolección de basura mediante:
System.gc();
Aunque dicha instrucción no garantiza la recolección de basuras. Solo se suele utilizar cuando nuestro
código genera basura mas rápidamente de lo que el recolector puede eliminar.
Inicialización de arrays en Java (I)
• Con la declaración int [] serie;
Tengo la referencia, pero todavía no tengo ningún array.

• Con int [] serie; = new int[5];

Tengo un array de 5 enteros apuntado por la referencia serie

¿Pero cuánto valen los enteros del array referenciado por serie?
Dos posibilidades:
→ O bien valen 0 (si serie ha sido declarada a nivel de clase).
→ O bien su valor es indefinido (si serie ha sido declarada dentro de un
método).
Inicialización de arrays en Java (II)
Valores iniciales por defecto: Cuando un array se declara como variable de
instancia, al crearlo sus elementos se inicializan de forma automática a:

• Cero, en el caso de tipos primitivos numéricos.

• Carácter nulo en el caso de char
• false en el caso de boolean
• null en el caso de referencias
Inicialización de arrays en Java (III)
La declaración, creación e inicialización de un array son operaciones distintas,
que pueden realizarse de forma independiente:
int [] serie; // Declaración.
serie = new int[20]; // Creación.
int serie2 [] = new int[100] // Declaración y creación

O hacerse a un tiempo en el momento de la declaración, continuando ésta con:

→ Un signo igual y
→ Una lista separada por comas y encerrada entre llaves de inicializadores.

int [] serie = {1,2,3,4,5}; //Se ha creado implicitamente

El tamaño del array queda determinado en este caso por el número de
elementos de la lista.
Inicialización de arrays en Java (IV)
Las inicializaciones del estilo: int [] serie = {1,2,3,4,5};

Son muy útiles en algunos casos, pero:

¿Y si necesitamos un array con 5000 elementos?
¿Y si nos interesa que todos los valores del array se inicialicen al
mismo valor?

Necesitamos acceder de forma sencilla y eficiente a cada una de las

posiciones del array. ¿Cómo? Mediante índices.
 De Objetos y Referencias (III)
1 int [] serie1 = {1, 2, 3};
2 int [] serie2 = {1, 2, 3};
3 serie1 = serie2;
4 serie2 = null;
¿Qué devuelve (serie1 == serie2)?
¿Son iguales los objetos apuntados por
serie1 y serie2?

ser ie1 serie 1 seri e2 serie1 ser ie2

1 1 1 1
2 2 2 1 2
1 3 2 3 3 2 3
3 3

seri e1
1 serie2
2
3
4
Un array se puede asignar a otro array (si son del mismo tipo):

int a[];
int b[]=new int[]{3,4,5,6,7,8};
a=b;
A diferencia de lo que podríamos intuir, lo que ocurre en el código anterior es que tanto a como b hacen
referencia al mismo array. Es decir el resultado seria:

Esta asignación provoca que cualquier cambio en a también cambie el array b (ya que, de hecho, es el
mismo array). Ejemplo:
int a[] ={3,3,3};
int b[];
b= a;
b[0]=8;
System.out.println(a[o]);//Escribirá el numero 8
Finalmente, como detalle final a este tema, el operador de igualdad (==) se puede utilizar con arrays,
pero nuevamente no compara el contenido sino si las referencias señalan al mismo array. Es decir:

Int a[]={3,3,3};
int b[] ={3,3,3};
System.out.println(a==b); //escribe false, aunque ambos arrays tienen el mismo contenido
int c[]=b;
System.out.println(b==c); //escribe true
 Uso de arrays: Indexación de elementos (I)
Nos podemos referir a cualquier elemento del array mediante el nombre del
array seguido de la posición del elemento entre corchetes.
El número de posición se denomina subíndice.

Consideremos la sentencia: serie

0 serie[0]
int [] serie = new int[10];
1 serie[1 ]
y la siguiente porción de código que inicializa los
4 serie[2 ]
elementos del array:
9 serie[3 ]
for (int i = 0; i < 10; i++)
16 serie[4 ]
serie[i] = i * i;
25 serie[5 ]
Los elementos del array ocupan posiciones de memoria contiguas, 36 serie[6]
que se numeran empezando por cero: serie[7 ]
49
• El primer elemento es serie[0] y el último serie[9]. 64 serie[8 ]

• Para referirnos al iésimo elemento escribimos serie[i-1]. 81 serie[9 ]

Uso de arrays: Indexación de elementos (II)
Los subíndices pueden ser cualquier expresión entera que evalúe un valor
dentro de los límites del array.
Ejemplo:
in t a = 4;
in t b = 3;
serie[a + b] += 2; // sumar dos a serie[7]

Los elementos de un array se comportan como cualquier otra variable de su

tipo y pueden usarse en expresiones.
Ejemplo:
int suma = serie[0] + serie[1];
Longitud de un array: IndexOutOfBoundsException
Consideremos otra vez el ejemplo ¿Qué ocurre si serie se ha
anterior: declarado así?
int a = 4; int serie[] = new int[5];
int b = 3;
O así:
serie[a + b] += 2;
int serie[] = new int[7];

No debemos acceder a posiciones del array inexistentes.

¿Por qué?
• En el mejor de los casos estamos accediendo a algo indefinido.
• En el peor podemos destruir información útil.
La JVM detecta los intentos de acceder a posiciones no existentes y lanza
una excepción que provoca (si no es tratada) que el programa aborte:
Ind exOutOf BoundsE xceptio n
 Longitud de un array. El atributo length
Los arrays son objetos. Los objetos tienen atributos que pueden consultarse
si son públicos.
Sería de gran ayuda poder preguntarle al array su longitud.

Java define el atributo length que guarda el número de elementos del array y
que se consulta según la sintaxis:
nom bre_arr ay.leng th

Ejemplo:
int serie[] = new int[10];
serie.length // nos devuelve el valor 10

¡ Cuando procesamos un array hay que tener precaución !

El subíndice no puede sobrepasar la posición del último elemento del array (length –1).
El subíndice no puede ser menor que cero.
Ejemplo 1: Inicialización y suma de los elementos de
un array de enteros.

cl ass Eje mplo1{

final int Tamaño_Array = 10;
int s[];
int total;
public static void main(String args[]){
s = new int[Tamaño_Array];
for (int i = 0; i < s.length; i++)
s[i] = 2 + 2 * i; // 2, 4, 6, ..., 20

// suma elementos
for ( int i= 0; i < s.length; i ++) total += s[i];
}
} // Fin de ejem plo 1
 Ejemplo 2: Análisis de un sondeo.
Se ha realizado una encuesta a 20 personas acerca de la calidad de la comida de un
restaurante en una escala de 1 a 10. Se trata de colocar las 20 respuestas en un array de
enteros y resumir los resultados del sondeo.
class Sondeo{
int rreessppuueessttaass[[ ] = {1, 2, 6, 4, 8, 5, 9, 7, 8, 1100,,
1, 6, 3, 8, 6, 10,3, 8, 2, 7};
int frecuencia[ ];
public static void main(String args[]){
frecuencia = new int[11];
// No uuttiilliizzaammooss el pprriimmeerr eelleemmeennttoo.. CCaaddaa rreessppuueessttaa es
// el subíndice del array frecuencia.
for ( int i = 0; i < respuestas.length; i++)
++frecuencia[respuestas[i]];
}
} // Fin de Sondeo
Los resultados son correctos porque el frecuencia se inicializó aauuttoom
mááttiiccaam
meennttee a 0.
Observaciones
• La palabra array se ha traducido de muchas maneras, sin que ninguna de
ellas haya cuajado por completo. Podemos encontrar en español: arreglos,
formaciones, matrices, vectores.

• Los arrays son objetos y por tanto accedemos a ellos usando referencias.
→ Sin embargo, no existe una clase array ni métodos asociados a los
arrays. Los arrays son una construcción del lenguaje.

• La expresión serie.length no es una invocación de un método, sino

la lectura de un dato asociado al array (su tamaño).
Observaciones
• No hay restricciones respecto del tipo de datos que puede contener un
a rra y .
→ Pueden ser tanto tipos de datos primitivos como referencias a
objetos de una clase.

• Los arrays tienen un tamaño fijo:

→ No pueden crecer ni disminuir su tamaño.
→ Se dice que son estructuras estáticas de datos (en
contraposición con las estructuras dinámicas de datos que si
pueden variar el tamaño).

• No obstante, las referencias de arrays se pueden asignar a arrays de

diferentes tamaños.
Ordenación de arrays: Algoritmo de la burbuja.
Array ordenado: Un array a está ordenado si se cumple que:
 pareja de subíndices i,j, si i  j  a[ i]  a[ j]

Algoritmo de la burbuja:

Sea el array a. Repetir (a.length – 1) veces:

1. Realizar una pasada por el array.
2. Comparar pares de elementos sucesivos.
→ Si un par está en orden se deja como está.
→ Si no se intercambian los valores.

En el array compara en cada pasada a[0] con a[1] , a[1] con a[2] ,
a[2] con a[3] y así sucesivamente.
 Ordenación de arrays: Algoritmo de la burbuja.
// Definido como variable de instancia
int [] a = new int [TamañoArray];
// Suponemos que está inicializado
public static void main(String args[] ) {
int intercambio;
for (int pasadas = 0; pasadas < a.length-1; pasadas++ )
for (int i = 0 ; i < a.length- 1- pasadas; i++)
if (a[i] > a[i+1]){
intercambio = a[i];
a[i] = a[i+1];
a[i+1] = intercambio;
}
}
Ordenación de arrays: Algoritmo de la burbuja.

• Un valor grande puede bajar varias int a[] = {4, 3, 2, 1}

posiciones de una sola pasada, pero
uno pequeño sólo puede subir una Inicial Pasada Pasada Pasada
posición. 1 2 3
4 3 2 1
• En la primera pasada el valor más
grande quedará en la última posición 3 2 1 2
del array (a.lenght –1). 2 1 3 3
1 4 4 4
• En la segunda pasada el segundo
valor más grande quedará en la
Pasada 1 Al entrar Al salir
penúltima posición.
i = 0 → 4, 3, 2, 1 3, 4, 2, 1
• Se puede comprobar que hacen falta i = 1 → 3, 4, 2, 1 3, 2, 4, 1
un número de pasadas igual a la i = 2 → 3, 2, 4, 1 3, 2, 1, 4
longitud del array menos 1.
Búsqueda en arrays: Búsquedas lineal y binaria

• Se trata de determinar si el array contiene un

elemento que coincide con el valor de una clave.
→ La clave de búsqueda.

• Se denomina búsqueda al proceso de encontrar ese

elemento clave.
 Búsqueda en arrays: Búsqueda lineal
Búsqueda lineal: compara cada elemento del array con la clave de
búsqueda.

• Si el array no está ordenado es igualmente

probable que el elemento buscado esté al
principio o al final.
→ El número medio de comparaciones es
igual a la mitad del tamaño del array. public static void main (String args []) {
• La búsqueda lineal funciona bien en arrays
pequeños, pero es muy poco eficiente en
arrays grandes y en arrays ordenados.
• Orden de complejidad: O(n)
// Definimos como variables de instancia
int a[] = {2,3,6,1,4,7,9,4,3,5};
int clave = 7;
for ( int n = 0; n < a.length; n++ )
if (a[n] == clave)
{System.out.println(“Lo encontré en “+ n);
break;}
}
Búsqueda en arrays: Búsqueda binaria
Algoritmo de búsqueda binaria.
Comparar la clave con el elemento situado en la mitad del array (elemento
medio).
• IF (clave == elemento medio) → Hemos terminado.
• ELSE IF (clave < elemento medio) → buscar en la pprriim
meerraa mitad del array,

• ELSE → buscar en la segunda mitad del array.

El proceso se repite sucesivamente hasta que:

• La clave sea igual al elemento medio del subarray que qquueeddaa..
OR
• El subarray que queda consta de un solo elemento distinto de la clave
Búsqueda en arrays: Búsqueda binaria
Es un algori tmo muy eficie nte.

El algoritmo de búsqueda binaria elimina de la búsqueda la mitad de los

elementos que quedan en el array después de cada comparación.

1024 elementos (1024 = 210) → 10 comparaciones como máximo.

1.048.576 elementos (220) → 20 comparaciones como máximo

El número máximo de comparaciones es el exponente de la primera potencia

de 2 mayor que el número de elementos del array.

Orden de complejidad: O(log2 n)

Pe ro sólo funcio na con arrays ordenad os

Búsqueda en arrays: Búsqueda binaria
int [] a = {2,4,6,8,10,12,14,16,18,20,22} Clave = 20

Subíndice 0 1 2 3 4 5 6 7 8 9 10
Valor 2 4 6 8 10 12 14 16 18 20 22

2
4
6
8
10
12
14 14
16 16
18 18
20 20 20 20
22 22 22
Búsqueda en arrays: Búsqueda binaria
class Búsqueda_Binaria {
int a[ ] = {2, 4, 6, 8, 10, 12, 14, 1 6, 18, 20, 22}

public static voi d main (St ring args []) {

int bajo = 0;
int alto = a.l ength –1;
int medio;
whil e (bajo < = alto) {
m edio = (ba jo + alto) / 2;
if (clave == a[medio ]) // se e ncontró
{System. out.printl n(“Lo enco ntré en “ + medio);
break;}
e lse if (cl ave < a[me dio])
alto = m edio – 1;
e lse
bajo = m edio + 1;
}
}

}
Arrays Multidimensionales en Java
Java no maneja directamente arrays de múltiples subíndices, pero
como los elementos de un array pueden ser cualquier cosa →

Java permite especificar arrays de un subíndice cuyos elementos

son también arrays de un subíndice.

 El resultado en la práctica es que se pueden manejar

tablas de dos o más subíndices.
 Arrays Bidimensionales (I)
Las tablas que requieren dos subíndices para identificar un elemento se
llaman arrays con doble subíndice.
• El primer subíndice se refiere a la fila (es el índice del array de arrays)
• El segundo subíndice se refiere a la columna (es el índice de cada uno de los
arrays del array de arrays)
• Un array de dos dimensiones de m filas y n columnas es un array m x n.

Ejemplo: En la tabla se muestra la disposición de los elementos de un

array a de 3x4:
int [][] a = new int[3][4];
a es un array de 3x4
Columna 0 Columna 1 Columna 2 Columna 3
enteros.
Fila 0 a[0] a[0][0] a[0][1] a[0][2] a[0][3 ]
aa[[ii]] es un array de 4
Fila 0 a[1] a[1][0] a[1][1] a[1][2] a[1][3 ] enteros.
Fila 2 a[2] a[2][0] a[2][1] a[2][2] a[2][3 ]
a[i][j] es un entero
 Arrays Bidimensionales (II)
Los arrays de dos dimensiones (en general de cualquier dimensión) se pueden
declarar e inicializar de manera similar a los arrays de una dimensión.

Ejemplo: Array con doble subíndice

b[0 ][0] b[0 ][1]
int b [][] = { {1,2}, {3,4,5} }
b[0] → 1 2
Los valores se agrupan por fila encerrados entre b[1] → 3 4 5
llaves:
b[1 ][0] b[1 ][1] b[1] [2]
1 y 2 inicializan b[0][0] y b[0][1]
3, 4 y 5 inicializan b[1][0], b[1][1] y b[1][2]

• En la declaración aparecen dos parejas de corchetes, porque Java mantiene arrays

de arrays. Hablar de arrays de dos o más dimensiones no es estrictamente correcto.

• Lo que estamos declarando es un array cuyos elementos son dos arrays, uno
conteniendo dos elementos {1,2} y el otro conteniendo tres elementos {3,4,5}.
 Arrays Bidimensionales (III)
int [][] matriz = { {11,12,13}, {21,22,23} };
System.out.println(matriz [[00]][[22]]));; // Imprime en pantalla 13

int [][] trian gulo = new int [3][] ;

triangulo[0] = new int[1 ];
triangulo[1] = new int[2 ];
triangulo[2] = new int[3 ]; tri angulo[0] → 0

tri angulo[1] → 0 1
triangulo[0][0] = 0;
Tri angulo[2] → 0 1 2
triangulo[1][0] = 0;
triangulo[1][1] = 1;
triangulo[2][0] = 0;
triangulo[2][1] = 1;
triangulo[2][2] = 2; O bien,

int[ ][] trian gulo = { { 0} ,{0,1} ,{0,1,2} } ;

¡ Triangulo tiene dos dimensiones pero no es una matriz !

Arrays Bidimensionales (IV)
Suma de los elementos de un array bidimensional:
class Recorrido_Array {

int a[][] = { {1,2}, {4} };

int total = 0;
public static void main (String args[] ) {
for (int fila = 0; fila < a.length; fila++)
for (int col = 0; col < a[fila].length; col++)
total += a[fila][col];
}
}
// a.length da el número de filas (número de elementos del array a)
// a[fila].length da el número de columnas (número de elementos
// del array a[fila])
Arrays Bidimensionales (V)
Se trata de calcular la nota máxima y mínima de un array de calificaciones, donde cada
fila representa un estudiante y cada columna representa una calificación en diferentes
exámenes
clas s Califica ción {
i nt notas[] [] = {{77, 68,86,73}, {96,87,89 ,81}, {70, 90,86,81}} ;

p ublic stat ic void ma in (String args[]){

int nota _baja = 10 0, nota_al ta = 0;
for (int i = 0; i < notas.le ngth; i++ )
for ( int j = 0; j < notas [i].length ; j++ )
if (notas[i] [j] < nota _baja) not a_baja = n otas[i][j] ;
System.o ut.println (“La nota baja es” + nota_baja );

for (int i = 0; i < notas.le ngth; i++)

for ( int j = 0; j < notas [i].length ; j++ )
if (notas[i] [j] > nota _alta) not a_alta = n otas[i][j] ;
System.o ut.println (“La nota alta es” + nota_alta );
}
}
Bucle for-each en Java
El bucle for-each, solo esta disponible en Java 5 y posteriores, tiene como función
recorrer un conjunto de objetos y aunque estamos tratando de ir por pasos porque aun
no hemos hablado de objetos no esta demás darlo a conocer.
La sintaxis es la siguiente:
for ( Tipo elemento : colección de Elementos ) {
Grupo de Sentencias;
}
Donde Tipo es el tipo de dato del elemento del conjunto, elemento es una variable
auxiliar que la primera vez que se ejecute el bucle tomará el valor del primer elemento del
conjunto, la segunda vez tomará el valor del segundo elemento del conjunto y así
sucesivamente. La colección de Elementos es el conjunto de elementos sobre los
cuales queremos iterar (generalmente un matriz). Cuando trabajemos con array veremos
ejemplos sobre este bucle.
De la forma tradicional podríamos recorrer un array de la siguiente forma:
String a[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Soria"};
for (int x=0;x<a.length;x++)
System.out.println(a[x]);
Así, para recorrer un array, con el foreach tendríamos lo siguiente:
for (String elemento: array)
System.out.println(elemento);

¿Como recorrer array bidimensional en java?

Ahí esta un ejemplo de recorrido de arreglos con un bucle tipo foreach

int [ ][ ] array={{1,2,3},{4,5,6}};
for (int [ ] a : array){
for (int b:a)
System.out.println (b+"\t");
System.out.println ();
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), es decir que para utilizar sus métodos hay que
utilizar simplemente esta sintaxis:

Arrays.metodo(argumentos);

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,-i);//Todo el array vale -1

También permite decidir desde que índice hasta que índice rellenamos:
Arrays.fill(valores,5,8,-i); //Del elemento 5 al 7 valdrán -1
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 si compara el
contenido. Ejemplo (comparación entre el operador de igualdad y el metodo 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}
Arrays.sort(x); //Estará completamente ordenado

Nos podemos encontrar varios métodos que nos permitirá ordenar arrays de distintos tipos de datos, ya
sean enteros, cadenas, objetos....
Vamos a ver un ejemplo de ordenación de un vector de cadena, primero lo veremos ordenado
ascendente y luego descendente.

El vector desordenado será el siguiente:

String [] stringArray = {"ab", "aB", "c", "0", "2", "1Ad", "a10"};

Si ahora le aplicamos el método sort de la clase que hemos indicado, el array saldrá ordenado de forma
ascendente. El código sería el siguiente:

//Ordenación ascendente

Arrays.sort (stringArray);

System.out.println ("****** Ordenando String Array *******");

for (String str : stringArray) {
System.out.println (str);
}

Si lo queremos ordenar de forma descendente, habría que indicarle al método que lo haga así. Para
este caso, el método quedaría de la siguiente forma:
 //Ordenación descendente

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

System.out.println ("****** Ordenando String Array *******");
for (String str : stringArray) {
System.out.println (str);
}

Otra opción que nos permite el método “sort” es una ordenación selectiva, es decir, de un array,
ordenar los elementos que le indiquemos en un rango dado. Es decir, el método en este caso sería de la
siguiente forma:

Arrays.sort (Object [], int startIndex, int endIndex)

Y un ejemplo del código sería el siguiente:

//Ordenamos los elementos que van desde la posición 3 a la 6
Arrays.sort(stringArray, 3, 6);

System.out.println ("****** Ordenando String Array *******");

for (String str : stringArray) {
System.out.println (str);
}
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 esta 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
Disponible desde la versión 1.6 del SDK, 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, solo 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 (también esta disponible desde la versión 1.6),solo que indica con dos
números de que elemento a que 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}

El metodo System.arraysCopy
La clase System también posee un metodo 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 (numero 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 1 1 2 3 3 3 3 3 3
La ventaja sobre el método copyOf de la clase Arrays esta en que este método funciona en cualquier
versión de Java.