List e ArrayList em Java

Em Java, quando se trabalha com coleções de dados, é comum precisar armazenar vários elementos em sequência. Para isso, existe a interface List, que define um tipo de coleção onde cada item ocupa uma posição (índice) e pode ser acessado diretamente por esse índice.

A implementação mais usada dessa interface é a classe ArrayList, que funciona como um "array dinâmico". Diferente de um array comum, que tem tamanho fixo, um ArrayList pode crescer ou diminuir conforme novos elementos são adicionados ou removidos.

Principais operações em listas

A interface List e a classe ArrayList oferecem métodos prontos para trabalhar com os elementos:

• Adicionar elementos: com add, é possível colocar um item no final da lista ou em uma posição específica.
• Acessar elementos: o método get retorna o item que está em determinado índice.
• Substituir elementos: com set, um item existente pode ser trocado por outro.
• Descobrir o tamanho: o método size retorna quantos elementos existem na lista.
• Verificar se contém: o método contains informa se um valor está presente.
• Remover elementos: com remove, um item pode ser retirado pelo valor ou pelo índice.
• Converter em array: com toArray, a lista pode ser transformada em um array comum.

Construtores de ArrayList

A classe ArrayList pode ser criada de diferentes formas:

• new ArrayList<>(): cria uma lista vazia.
• new ArrayList<>(colecao): cria a lista já com os elementos de outra coleção.
• new ArrayList<>(capacidadeInicial): cria uma lista com uma capacidade mínima pré-definida.

Definir a capacidade inicial é útil quando já se sabe quantos elementos, em média, serão usados, pois evita que a lista precise realocar memória várias vezes.

Exemplo prático

O código abaixo mostra como criar um ArrayList de strings e trabalhar com alguns dos métodos mais comuns:

import java.util.ArrayList;

public class Program {
    public static void main(String[] args) {
        ArrayList<String> people = new ArrayList<String>();

        people.add("Tom");
        people.add("Alice");
        people.add("Kate");
        people.add("Sam");
        people.add(1, "Bob"); // adiciona no índice 1

        System.out.println(people.get(1)); // acessa o elemento no índice 1
        people.set(1, "Robert"); // substitui o elemento no índice 1

        System.out.printf("ArrayList has %d elements \n", people.size());
        for(String person : people){
            System.out.println(person);
        }

        if(people.contains("Tom")){
            System.out.println("ArrayList contains Tom");
        }

        people.remove("Robert");
        people.remove(0);

        Object[] peopleArray = people.toArray();
        for(Object person : peopleArray){
            System.out.println(person);
        }
    }
}

Saída esperada

Bob
ArrayList has 5 elements
Tom
Robert
Alice
Kate
Sam
ArrayList contains Tom
Alice
Kate
Sam

Observações importantes

No exemplo acima, o ArrayList foi configurado para armazenar apenas elementos do tipo String. Esse recurso se chama generics: ao indicar ArrayList<String>, a lista aceita apenas valores do tipo String.

Embora o ArrayList cresça automaticamente quando precisa armazenar mais elementos, internamente ele ainda usa um array como estrutura base. Isso significa que, quando a capacidade é ultrapassada, um novo array é criado e os elementos antigos são copiados, o que consome processamento.

Por isso, em cenários onde já se sabe que a lista terá, por exemplo, cerca de 25 elementos, é melhor declarar assim:

ArrayList<String> people = new ArrayList<String>(25);

Ou então garantir a capacidade mínima com o método:

people.ensureCapacity(25);

Esses cuidados ajudam a tornar o programa mais eficiente.

Resumo

• List é a interface que define listas em Java.
• ArrayList é a implementação mais comum dessa interface.
• Permite adicionar, acessar, substituir e remover elementos com facilidade.
• O tamanho da lista é dinâmico, mas internamente usa um array.
• Definir uma capacidade inicial ajuda a evitar custos extras de realocação.

📝 Exercícios

Tarefa 1: Criar uma Sublista

Objetivo: Complete o método criarSublista para que ele receba uma lista de nomes e retorne apenas os elementos entre os índices start e end.

Código inicial:

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

public class Main {
    public static void main(String[] args) {
        ArrayList<String> nomes = new ArrayList<>();
        nomes.add("Tom");
        nomes.add("Alice");
        nomes.add("Kate");
        nomes.add("Sam");
        nomes.add("Bob");

        List<String> sub = criarSublista(nomes, 1, 4);
        System.out.println(sub); // Esperado: [Alice, Kate, Sam]
    }

    static List<String> criarSublista(ArrayList<String> lista, int start, int end) {
        // Escreva seu código aqui.
        // Você precisa retornar uma sublista de lista.

    }
}

static List<String> criarSublista(ArrayList<String> lista, int start, int end) {
    return lista.subList(start, end);
}

Tarefa 2: Ordenar Números em Ordem Decrescente

Objetivo: Complete o método ordenarDecrescente para que ele organize uma lista de inteiros do maior para o menor.

Código inicial:

import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numeros = new ArrayList<>();
        numeros.add(5);
        numeros.add(1);
        numeros.add(9);
        numeros.add(3);

        ordenarDecrescente(numeros);
        System.out.println(numeros); // Esperado: [9, 5, 3, 1]
    }

    static void ordenarDecrescente(ArrayList<Integer> lista) {
        // Escreva seu código aqui.
        // Você precisa ordenar em ordem decrescente.

    }
}

static void ordenarDecrescente(ArrayList<Integer> lista) {
    lista.sort(Comparator.reverseOrder());
}

Tarefa 3: Encontrar Primeira e Última Ocorrência

Objetivo: Complete o método encontrarIndices para que ele mostre o índice da primeira e da última ocorrência de um valor em uma lista.

Código inicial:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> palavras = new ArrayList<>();
        palavras.add("Java");
        palavras.add("C++");
        palavras.add("Java");
        palavras.add("Python");
        palavras.add("Java");

        encontrarIndices(palavras, "Java");
        // Esperado:
        // Primeira ocorrência: 0
        // Última ocorrência: 4
    }

    static void encontrarIndices(ArrayList<String> lista, String valor) {
        // Escreva seu código aqui.
        // Você precisa mostrar primeira e última ocorrência.

    }
}

static void encontrarIndices(ArrayList<String> lista, String valor) {
    int primeiro = lista.indexOf(valor);
    int ultimo = lista.lastIndexOf(valor);

    System.out.println("Primeira ocorrência: " + primeiro);
    System.out.println("Última ocorrência: " + ultimo);
}