ARRAYS EN JAVA

Zenón José Hernández Figueroa, José Daniel González Domínguez,

Recorrer un array ........................................................................................................................3

Estructuras multidimensionales ...................................................................................................3

Clase java.util.arrays ....................................................................................................................4

Arrays en Java
1
Conceptualización

En Java, el tipo de datos básicos para representar secuencias de valores son los arrays. A
diferencia de las tuplas o listas de Python, todos los elementos de un array tienen que ser del
mismo tipo, que debe declararse. Para declarar una variable como array, hay que poner el tipo
de los elementos seguido por corchetes:

int[] arrayOfInt;

Se puede inicializar un array asignándole una secuencia de valores, separados por comas y
encerrados entre llaves:

int[] arrayOfInt = {10, 15, 20, 30, 40};

Tambien se puede inicializar creando un objeto array de un tamaño determinado con el

int[] arrayOfInt = new int[5];

Los elementos de los arrays de números se inicializan con el valor 0, o 0.0, según el tipo. Los
arrays de elementos de otros tipos se inicializan con el valor null.

Los arrays de Java se parecen a las tuplas de Python en que una vez creados no pueden cambiar
de tamaño (no se les puede añadir elementos ni quitar elementos), pero se parecen a las listas
en que los elementos pueden modificarse.

Los elementos de un array en Java se numeran con índices empezando con el valor 0. Para
acceder a un elemento de un array, se usa su índice entre corchetes junto al nombre de la
variable que lo referencia:

int value = arrayOfInt[3];

Para cambiar un valor, se pone esa expresión a la izquierda de una asignación:

arrayOfInt[3] = 10;

El número de elementos de un array se puede conocer accediendo al atributo length:

int size = arrayOfInt.length;

Arrays en Java
2
Recorrer un array

Se puede recorrer una secuencia usando un bucle que itere por los índices de la misma:

class Main {
public static void main(String[] arg) {
int[] myArray = {10, 15, 20, 30, 40};
for (int i = 0; i < myArray.length; i++) {
System.out.println(myArray[i]);
}
}
}

class Main {
public static void main(String[] arg) {
int[] myArray = {10, 15, 20, 30, 40};
for (int value: myArray) {
System.out.println(value);
}
}
}

Estructuras multidimensionales

En Java se pueden tener arrays de arrays:

int[][] myArray = {
{10, 15, 20, 30, 40},
{12, 14, 16, 18},
{11, 17, 23, 29, 31}
};

Para acceder a un elemento en concreto:

System.out.println(myArray[1][3]);

Para recorrer una estructura multidimentsional, habrá que anidar tantos bucles como
dimensiones tenga la estructura, independientemente de si se recorre por índices o por
valores:

// Recorrido por índices

Arrays en Java
3
// Recorrido por valores
for (int[] row: myArray) {
for (int value: row) {
System.out.println(value);
}
}

Clase java.util.arrays

La clase Arrays de Java (paquete java.util) ofrece funciones de clase para realizar varias
operaciones útiles sobre arrays.

El método sort() ordena de menor a mayor un array. Se le puede especificar un rango de índices
para ordenar solo los elementos comprendidos en él:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] array1 = {90, 80, 70, 60, 50, 40, 30, 20, 10};
Arrays.sort(array1, 3, 6); // [90, 80, 70, 40, 50, 60, 30, 20, 10]
Arrays.sort(array1); // [10, 20, 30, 40, 50, 60, 70, 80, 90]
}
}

El método binarySearch, dado un array ordenado y un valor, busca el valor en el array, usando
un algoritmo de búsqueda binaria, y devuelve su posición. Si no lo encuentra, devuelve el valor
(-(punto de inserción)-1), donde punto de inserción representa la posición en la que debería
estar:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] myArray = {10, 15, 20, 30, 40};
System.out.println(Arrays.binarySearch(myArray, 15)); // Muestra 1
System.out.println(Arrays.binarySearch(myArray, 45)); // Muestra -6
}
}

El método copyOf() copia un array, creando uno nuevo con una longitud específicada. Si la
longitud especificada es menor que la del array original, lo trunca, y si es mayor, rellena con
valores que dependen del tipo de los elementos del array:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {

Arrays en Java
4
 int[] myArray = {10, 15, 20, 30, 40};
int[] shorter = Arrays.copyOf(myArray, 3)); // {10, 15, 20}
int[] longer = Arrays.copyOf(myArray, 7)); // {10, 15, 20, 30, 40,
0, 0}
}
}

El método copyOfRange() copia un trozo de un array, especificado por un rango de índices,

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] myArray = {10, 15, 20, 30, 40};
int[] other = Arrays.copyOfRange(myArray, 2, 5); // {20, 30, 40}
}
}

El método equals(), devuelve true si los dos arrays que compara son iguales:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] array1 = {10, 15, 20, 30, 40};
int[] array2 = {15, 10, 30, 40, 20};
System.out.println(Arrays.equals(array1, array2)); // Muestra false
}
}

Cuando los elementos de los arrays son objetos (no valores de tipos primitivos), el
método equals() hace una comparación superficial (shallow), para hacer una comparación en
profundidad (deep), hay que usar el método deepEquals().

El método fill() rellena los elementos de un array con un valor determinado. Se puede
especificar un rango de índices a rellenar:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] array1 = new int[10]; // {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
Arrays.fill(array1, 1); // {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
Arrays.fill(array1, 4, 8, 2); // {1, 1, 1, 1, 2, 2, 2, 2, 1, 1}
}
}

Arrays en Java
5
El método toString() devuelve un objeto de tipo String que representa el contenido del array
que se le pasa:

import java.util.Arrays;
class Main {
public static void main(String[] arg) {
int[] array1 = {10, 15, 20, 30, 40};
String string1 = Arrays.toString(array1); // "[10, 15, 20, 30, 40]"
}
}

Nótese que, como string, el contenido del array se representa entre corchetes, aunque en Java,
los literales array se construyen usando llaves.

Arrays en Java
6