Como usar Java ArrayList

ArrayList é uma das es­tru­tu­ras de dados mais uti­li­za­das em Java. Ela permite modificar e armazenar di­na­mi­ca­mente uma coleção de objetos. Neste tutorial, vamos apre­sen­tar a sintaxe de Java ArrayList e explicar quando e como utilizá-la.

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

Uma Java ArrayList é dinâmica, o que significa que ela aumenta e diminui de tamanho a depender dos elementos adi­ci­o­na­dos ou removidos. Vale notar que a classe ArrayList faz parte do Java Col­lec­ti­ons Framework. Ao contrário de arrays, Ar­ray­Lists precisam ser im­por­ta­das da bi­bli­o­teca java.util.

Ar­ray­Lists são a escolha adequada quando o com­pri­mento de uma lista em Java pode variar po­ten­ci­al­mente. Exemplos incluem armazenar objetos, buscar ou ordenar dados e criar listas ou filas.

Em con­tra­par­tida, não é possível alterar o tamanho de um array. Assim, de pre­fe­rên­cia, você deverá saber, an­te­ci­pa­da­mente, quantos objetos o array irá conter. Arrays são adequados para gerenciar conjuntos pré-definido de tipos de dados pri­mi­ti­vos, como int, float, char e boolean.

Uma des­van­ta­gem da ArrayList é que ela pode demorar mais para ser acessada. Enquanto arrays têm blocos contínuos e fixos de memória, objetos em Ar­ray­Lists não ficam ar­ma­ze­na­dos de maneira contígua. É im­por­tante levar em con­si­de­ra­ção as vantagens e des­van­ta­gens das es­tru­tu­ras de dados para escolher aquela que melhor se adapta ao uso que você fará.

Qual é a sintaxe de Java ArrayList?

Antes de criar uma ArrayList, você deve importar a classe cor­res­pon­dente da bi­bli­o­teca java.util:

import java.util.ArrayList;

A sintaxe geral é:

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

Tipo se refere ao res­pec­tivo tipo de dado na Java ArrayList.

O próximo passo é criar listas de strings e integers:

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

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

Ar­ray­Lists usam a classe wrapper dos tipos de dados pri­mi­ti­vos cor­res­pon­den­tes para tratá-los como objetos. Isso significa que você precisará es­pe­ci­fi­car Integer em vez de int.

Exemplos de métodos Java ArrayList

Operações como adicionar ou remover elementos não são re­a­li­za­das, na ArrayList, com ope­ra­do­res Java, mas por métodos pre­de­fi­ni­dos. Ape­sen­ta­re­mos, agora, os métodos mais comuns de ArrayList.

Adicionar elementos

Após criar o ArrayList “cores” (tipo String), vamos adicionar vários elementos a ele usando o método .add():

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
    }
}

O código resultará em:

ArrayList: [azul vermelho verde]

Remover elementos

Para remover objetos de uma Java ArrayList, podemos usar o método .remove() e es­pe­ci­fi­car o índice do elemento:

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
        String cor = cores.remove(1);
        System.out.println("ArrayList: " + cores);
        System.out.println("Elemento Removido: " + cor);
    }
}

A saída mostra a ArrayList mo­di­fi­cada e o elemento que foi removido:

ArrayList: [azul verde]
Elemento Removido: vermelho

Como na maioria das lin­gua­gens de pro­gra­ma­ção, a contagem em Java começa em 0. Isso significa que o elemento removido no índice 1 é vermelho.

Acessar elementos

Usando o método .get(), podemos acessar um elemento em uma posição es­pe­cí­fica.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> roupas = new ArrayList<>();
        roupas.add("jaqueta");
        roupas.add("camisa");
        roupas.add("pulôver");
        System.out.println("ArrayList: " + roupas);
        String str = roupas.get(2);
        System.out.print("Elemento no índice 2: " + str);
    }
}

Como resultado, recebemos:

ArrayList: [jaqueta camisa pulôver]
Elemento no índice 2: pulôver

Alterar elementos

Com .set(), podemos alterar um elemento, atri­buindo um novo elemento em um índice es­pe­cí­fico.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
        cores.set(2, "amarelo");
        System.out.println("ArrayList Modificado: " + cores);
    }
}

Agora vemos amarelo em vez de verde no índice 2:

ArrayList: [azul vermelho verde]
ArrayList Modificado: [azul vermelho amarelo]

De­ter­mi­nar tamanho da Java ArrayList

O número de elementos no ArrayList pode ser fa­cil­mente calculado usando o método .size():

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println(cores.size());
    }
}

Este é o resultado:

3

Clas­si­fi­car e iterar sobre ArrayList

Para clas­si­fi­car a Java ArrayList, a classe Col­lec­ti­ons deve ser importada. Para a iteração, usamos um loop for-each em Java. A cada iteração do loop, o res­pec­tivo elemento é exibido no console.

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

Os elementos da ArrayList são exibidos do menor para o maior:

9
17
20
54