ArrayList de Java: cómo crear y utilizar una de estas listas

El ArrayList es una de las es­tru­c­tu­ras de datos más uti­li­za­das en Java. Permite modificar y almacenar di­ná­mi­ca­me­n­te una colección de objetos. En este artículo te pre­se­n­ta­mos la sintaxis y los métodos de ArrayList de Java.

¿Cuál es la di­fe­re­n­cia entre ArrayList y Array en Java?

El ArrayList de Java tiene un tamaño dinámico, lo que significa que los elementos pueden ser fá­ci­l­me­n­te añadidos o eli­mi­na­dos. Además, la clase ArrayList pertenece al Java Co­lle­c­tio­ns Framework y, a di­fe­re­n­cia de los arrays, no está di­s­po­ni­ble de forma nativa. Debe im­po­r­tar­se de la bi­blio­te­ca java.util.

El ArrayList es una opción apropiada cuando la longitud de la lista de Java puede variar. Algunos ejemplos son el al­ma­ce­na­mie­n­to de objetos, la búsqueda u or­de­na­ción de datos y la creación de listas o colas.

El tamaño del tipo de datos array no puede mo­di­fi­car­se. Por lo tanto, el número de objetos que debe contener el array debe conocerse de antemano. Por ello, los arrays son adecuados para gestionar un conjunto pre­de­fi­ni­do de tipos de datos pri­mi­ti­vos como int, float, chat o boolean.

Una de­s­ve­n­ta­ja de ArrayList es el mayor tiempo de acceso. Mientras que con los arrays existe una zona de memoria reservada fija, con ArrayList esta no es contigua. Por lo tanto, es im­po­r­ta­n­te tener en cuenta las ventajas y de­s­ve­n­ta­jas re­s­pe­c­ti­vas y se­le­c­cio­nar la es­tru­c­tu­ra de datos adecuada para cada uso.

La sintaxis de Java ArrayList

Antes de crear un ArrayList, la clase co­rre­s­po­n­die­n­te debe ser importada de la librería java.util.

import java.util.ArrayList;

La sintaxis general es:

ArrayList<Type> arrayList= new ArrayList<>();

“Type” re­pre­se­n­ta el tipo de datos re­s­pe­c­ti­vo de Java ArrayList.

A co­n­ti­nua­ción, creamos listas de tipo String e Integer.

ArrayList<String> arrayList= new ArrayList<>();

ArrayList<Integer> arrayList= new ArrayList<>();

ArrayList utiliza la clase wrapper co­rre­s­po­n­die­n­te de los tipos de datos pri­mi­ti­vos para que sean tratados como objetos. Por lo tanto, ne­ce­si­ta­mos es­pe­ci­fi­car Integer en lugar de int.

Ejemplos de métodos ArrayList de Java

Ope­ra­cio­nes como añadir o eliminar elementos no se realizan con ArrayList uti­li­za­n­do ope­ra­do­res Java, sino a través de métodos pre­de­fi­ni­dos. A co­n­ti­nua­ción, te mostramos los métodos ArrayList más comunes.

Añadir elementos

Una vez creada la ArrayList “colors” de tipo String, añadimos varios elementos con el método .add().

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
    }
}

Esto da este resultado:

ArrayList: [blue, red, green]

Eliminar elementos

Para eliminar objetos de un ArrayList Java, uti­li­za­mos el método .remove() con la es­pe­ci­fi­ca­ción del índice del elemento.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        String color = colors.remove(1);
        System.out.println("ArrayList: " + colors);
        System.out.println("Removed Element: " + color);
    }
}

El resultado muestra la ArrayList mo­di­fi­ca­da y el elemento eliminado:

ArrayList: [blue, green]
Removed Element: red

Como en la mayoría de los lenguajes de pro­gra­ma­ción, en Java se comienza a contar en la posición 0. Por lo tanto, el elemento eliminado en el índice 1 es red.

Acceso a los elementos de una Java ArrayList

Con la función .get() accedemos a un elemento en una posición concreta.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}

Como resultado obtenemos:

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover

Modificar elementos

Con .set() es­ta­ble­ce­mos un nuevo elemento en un índice es­pe­cí­fi­co.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        colors.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colors);
    }
}

En el resultado vemos ahora yellow en vez de green en el índice 2:

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]

De­te­r­mi­nar la longitud del Java ArrayList

El número de elementos de un ArrayList se puede calcular fá­ci­l­me­n­te con el método .size().

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println(colors.size());
    }
}

Como resultado obtenemos:

3

Ordenar e iterar a través de un ArrayList

Para ordenar un ArrayList en Java, hay que importar la clase Co­lle­c­tio­ns. Para la iteración uti­li­za­mos un bucle Java For Each. Para cada iteración del bucle, el elemento re­s­pe­c­ti­vo es enviado a la consola.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}

Los elementos del ArrayList se muestran en orden as­ce­n­de­n­te:

9
17
20
54