ArrayList do Java: como criar e utilizar uma dessas listas

A ArrayList é uma das es­tru­tu­ras de dados mais uti­li­za­das em Java. Permite modificar e armazenar di­na­mi­ca­mente uma coleção de objetos. Neste artigo, apre­sen­ta­mos a sintaxe e os métodos da ArrayList do Java.

Qual é a diferença entre ArrayList e Array em Java?

A ArrayList do Java tem um tamanho dinâmico, o que significa que os elementos podem ser fa­cil­mente adi­ci­o­na­dos ou removidos. Além disso, a classe ArrayList pertence ao Java Col­lec­ti­ons Framework e, ao contrário das matrizes, não está dis­po­ní­vel de forma nativa. Deve ser importada da bi­bli­o­teca java.util.

A ArrayList é uma opção adequada quando o com­pri­mento da lista Java pode variar. Alguns exemplos são o ar­ma­ze­na­mento de objetos, a pesquisa ou ordenação de dados e a criação de listas ou filas.

O tamanho do tipo de dados array não pode ser alterado. Portanto, o número de objetos que o array deve conter deve ser conhecido an­te­ci­pa­da­mente. Por isso, os arrays são adequados para gerir um conjunto pre­de­fi­nido de tipos de dados pri­mi­ti­vos, como int, float, chat ou boolean.

Uma des­van­ta­gem do ArrayList é o maior tempo de acesso. Enquanto que com os arrays existe uma área de memória reservada fixa, com o ArrayList esta não é contígua. Portanto, é im­por­tante ter em conta as res­pe­ti­vas vantagens e des­van­ta­gens e se­le­ci­o­nar a estrutura de dados adequada para cada uti­li­za­ção.

A sintaxe do Java ArrayList

Antes de criar uma ArrayList, a classe cor­res­pon­dente deve ser importada da bi­bli­o­teca java.util.

import java.util.ArrayList;

A sintaxe geral é:

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

“Type” re­pre­senta o tipo de dados res­pec­tivo do Java ArrayList.

Em seguida, criamos listas do tipo String e Integer.

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

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

ArrayList utiliza a classe wrapper cor­res­pon­dente dos tipos de dados pri­mi­ti­vos para que sejam tratados como objetos. Portanto, pre­ci­sa­mos es­pe­ci­fi­car Integer em vez de int.

Exemplos de métodos ArrayList em Java

Operações como adicionar ou eliminar elementos não são re­a­li­za­das com ArrayList uti­li­zando ope­ra­do­res Java, mas sim através de métodos pre­de­fi­ni­dos. A seguir, mostramos os métodos ArrayList mais comuns.

Adicionar elementos

Depois de criar a ArrayList «colors» do tipo String, adi­ci­o­na­mos vários elementos com o 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);
    }
}

Isso dá este resultado:

ArrayList: [blue, red, green]

Remover elementos

Para remover objetos de uma ArrayList Java, usamos o método .remove() com a es­pe­ci­fi­ca­ção do índice do 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);
    }
}

O resultado mostra a ArrayList mo­di­fi­cada e o elemento removido:

ArrayList: [blue, green]
Removed Element: red

Como na maioria das lin­gua­gens de pro­gra­ma­ção, em Java a contagem começa na posição 0. Portanto, o elemento eliminado no índice 1 é red.

Acesso aos elementos de uma Java ArrayList

Com a função .get(), acedemos a um elemento numa posição es­pe­cí­fica.

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, obtemos:

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

Modificar elementos

Com .set(), es­ta­be­le­ce­mos um novo elemento num índice es­pe­cí­fico.

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);
    }
}

No resultado, vemos agora yellow em vez de green no índice 2:

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

De­ter­mi­nar o com­pri­mento da Java ArrayList

O número de elementos de uma ArrayList pode ser fa­cil­mente calculado com o 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, obtemos:

3

Ordenar e iterar através de uma ArrayList

Para ordenar uma ArrayList em Java, é ne­ces­sá­rio importar a classe Col­lec­ti­ons. Para a iteração, uti­li­za­mos um loop Java For Each. Para cada iteração do loop, o elemento res­pec­tivo é enviado para a 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);
        }
    }
}

Os elementos da ArrayList são apre­sen­ta­dos por ordem crescente:

9
17
20
54