ArrayList em Java: criar, adicionar, remover, percorrer e ordenar

Uma lista que se redimensiona sozinha

Um array comum do Java tem um comprimento fixo: se você decidir por dez espaços, terá dez espaços para sempre. ArrayList é a alternativa redimensionável do java.util - ele cresce conforme você adiciona e encolhe conforme você remove, e traz métodos úteis para o que você realmente faz com uma lista.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Repare no tipo entre os sinais de menor e maior - List<String> - que diz ao compilador que esta lista armazena valores String. O <> (o "diamante") à direita permite que o Java infira o mesmo tipo sem repeti-lo. E observe que você importa java.util.ArrayList; ele não está disponível por padrão.

Declare como List, construa como ArrayList

Você quase sempre verá a variável declarada com a interface List em vez do ArrayList concreto:

List<String> names = new ArrayList<>();

É um bom hábito, não uma regra. Programar para a interface List significa que o resto do seu código não se importa com qual implementação de lista você usou, então você pode trocá-la por outra mais tarde sem mexer nele. Para o uso do dia a dia, as duas se comportam da mesma forma.

Adicionar, obter e alterar

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // adiciona no final
        fruits.add("banana");
        fruits.add(1, "cherry");  // insere no índice 1

        System.out.println(fruits.get(0));   // lê pelo índice
        fruits.set(0, "apricot");            // sobrescreve o índice 0

        System.out.println(fruits);
    }
}

• add(value) adiciona no final.
• add(index, value) insere numa posição, deslocando os elementos posteriores para a direita.
• get(index) lê o elemento numa posição (começando em zero).
• set(index, value) sobrescreve um elemento existente.

Os índices começam em zero, e get em um índice fora do intervalo lança IndexOutOfBoundsException.

Removendo elementos

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // remove pelo valor (primeira correspondência)
        fruits.remove(0);         // remove pelo índice

        System.out.println(fruits);
    }
}

Existe uma armadilha clássica quando a lista armazena Integer. remove(int) é "remover pelo índice" e remove(Object) é "remover pelo valor", então:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // remove o índice 1 -> o valor 20
nums.remove(Integer.valueOf(20));    // remove o valor 20

Envolva o valor em Integer.valueOf(...) quando você quer dizer "remova este valor", e não "remova este índice".

Tamanho, contains e buscas por índice

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) cria rapidamente uma lista imutável; passá-la ao construtor do ArrayList te dá uma cópia mutável já preenchida com esses valores.

Percorrendo um ArrayList

O laço mais limpo é o for aprimorado (o "for-each"):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Quando você também precisa do índice, use um laço contado com size() e get(i):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Uma regra: não adicione nem remova elementos de uma lista enquanto um laço for-each a percorre - isso lança ConcurrentModificationException. Para apagar itens correspondentes com segurança, use removeIf:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // descarta os números pares
        System.out.println(nums);
    }
}

Ordenação

Collections.sort ordena uma lista no próprio local usando a ordem natural (alfabética para strings, numérica para números):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // decrescente
        System.out.println(nums);
    }
}

Para ordenações personalizadas, passe um Comparator para list.sort(...) - por exemplo names.sort(Comparator.comparingInt(String::length)) para ordenar pelo comprimento.

ArrayList armazena objetos, não primitivos

Você não pode escrever ArrayList<int>. Os genéricos só funcionam com tipos de objeto, então use a classe wrapper Integer, Double, Boolean e assim por diante:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // o int 95 sofre autoboxing para Integer
        scores.add(88);

        int first = scores.get(0);  // sofre auto-unboxing de volta para int
        System.out.println(first + scores.get(1));
    }
}

O autoboxing do Java converte para você entre int e Integer, então isto se lê de forma natural - só lembre que a própria lista armazena objetos Integer.

Próximo: HashMap

ArrayList é a ferramenta certa quando você se importa com a ordem e a posição. Quando você precisa buscar coisas por uma chave - um nome de usuário para um usuário, um código de produto para um preço - você quer um HashMap, que é a próxima página.