List e ArrayList

ArrayList é a coleção mais comumente usada. Esta lição cobre o uso detalhado de List.

ArrayList

ArrayList é um array dinâmico baseado em implementação de array.

Características

Característica	Descrição
Ordenada	Elementos na ordem de inserção
Permite duplicatas	Pode ter elementos iguais
Acesso por índice	Acessar elementos por índice
Crescimento dinâmico	Expansão automática de capacidade

Criando ArrayList

JAVA

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

// Método 1: Capacidade padrão
List<String> list1 = new ArrayList<>();

// Método 2: Capacidade especificada
List<String> list2 = new ArrayList<>(100);

// Método 3: De outra coleção
List<String> list3 = new ArrayList<>(list1);

Operações Básicas

Adicionando Elementos

JAVA

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

list.add("Alice");        // Adicionar ao final
list.add("Bob");
list.add(0, "Charlie");   // Adicionar em posição específica

System.out.println(list);  // [Charlie, Alice, Bob]

Obtendo Elementos

JAVA

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");

String first = list.get(0);  // Alice
int size = list.size();       // 2

Modificando Elementos

JAVA

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");

list.set(0, "Charlie");  // Mudar primeiro elemento para Charlie
System.out.println(list);  // [Charlie, Bob]

Removendo Elementos

JAVA

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Charlie");

list.remove(0);           // Remover por índice
list.remove("Bob");       // Remover por conteúdo
System.out.println(list);  // [Charlie]

Encontrando Elementos

JAVA

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Charlie");

boolean has = list.contains("Bob");    // true
int index = list.indexOf("Charlie");   // 2
int lastIndex = list.lastIndexOf("Alice");  // 0

Métodos de Travessia

Método 1: Loop for

JAVA

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Charlie");

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

Método 2: for-each

JAVA

for (String name : list) {
    System.out.println(name);
}

Método 3: Iterator

JAVA

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

Método 4: Lambda

JAVA

list.forEach(name -> System.out.println(name));
list.forEach(System.out::println);

Ordenação

Usando Collections.sort()

JAVA

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

List<Integer> numbers = new ArrayList<>();
numbers.add(3);
numbers.add(1);
numbers.add(4);
numbers.add(1);
numbers.add(5);

Collections.sort(numbers);  // Ascendente
System.out.println(numbers);  // [1, 1, 3, 4, 5]

Collections.sort(numbers, Collections.reverseOrder());  // Descendente
System.out.println(numbers);  // [5, 4, 3, 1, 1]

Usando Comparator

JAVA

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

List<String> names = new ArrayList<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");

// Ordem alfabética
names.sort((a, b) -> a.compareTo(b));
System.out.println(names);  // [Alice, Bob, Charlie]

// Por comprimento
names.sort(Comparator.comparingInt(String::length));
System.out.println(names);  // [Bob, Alice, Charlie]

Outros Métodos Comuns

Método	Descrição
`addAll(Collection)`	Adicionar todos os elementos
`removeAll(Collection)`	Remover todos os elementos correspondentes
`retainAll(Collection)`	Manter interseção
`clear()`	Limpar tudo
`isEmpty()`	Está vazio
`toArray()`	Converter para array
`subList(int, int)`	Obter sublista

Exemplo: Operações em Lote

JAVA

List<String> list1 = new ArrayList<>();
list1.add("A");
list1.add("B");
list1.add("C");

List<String> list2 = new ArrayList<>();
list2.add("B");
list2.add("C");
list2.add("D");

// União
List<String> union = new ArrayList<>(list1);
union.addAll(list2);
System.out.println("União: " + union);  // [A, B, C, B, C, D]

// Interseção
List<String> intersection = new ArrayList<>(list1);
intersection.retainAll(list2);
System.out.println("Interseção: " + intersection);  // [B, C]

// Diferença
List<String> diff = new ArrayList<>(list1);
diff.removeAll(list2);
System.out.println("Diferença: " + diff);  // [A]

▶ Experimente

LinkedList

LinkedList é uma implementação de List baseada em lista duplamente encadeada.

Características

Característica	ArrayList	LinkedList
Estrutura subjacente	Array	Lista duplamente encadeada
Acesso aleatório	O(1)	O(n)
Inserir no início	O(n)	O(1)
Inserir no final	O(1)	O(1)
Uso de memória	Menos	Mais (ponteiros)

Métodos Específicos do LinkedList

JAVA

LinkedList<String> linkedList = new LinkedList<>();

// Operações de início/fim
linkedList.addFirst("A");
linkedList.addLast("B");
linkedList.addLast("C");

String first = linkedList.getFirst();
String last = linkedList.getLast();

linkedList.removeFirst();
linkedList.removeLast();

Guia de Seleção

Cenário	Recomendação
Acesso aleatório frequente	ArrayList
Inserção/remoção frequente no início	LinkedList
Uso geral	ArrayList

Exemplo: Gerenciamento de Notas de Estudantes

JAVA

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

public class StudentGrade {
    private String name;
    private int score;
    
    public StudentGrade(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    public String getName() { return name; }
    public int getScore() { return score; }
    
    @Override
    public String toString() {
        return name + ": " + score;
    }
    
    public static void main(String[] args) {
        List<StudentGrade> students = new ArrayList<>();
        students.add(new StudentGrade("Alice", 95));
        students.add(new StudentGrade("Bob", 88));
        students.add(new StudentGrade("Charlie", 92));
        students.add(new StudentGrade("David", 85));
        
        // Ordenar por pontuação descendente
        students.sort((a, b) -> b.getScore() - a.getScore());
        System.out.println("Ordenado por pontuação:");
        students.forEach(System.out::println);
        
        // Encontrar maior pontuação
        StudentGrade top = students.stream()
            .max(Comparator.comparingInt(StudentGrade::getScore))
            .orElse(null);
        System.out.println("Maior: " + top);
        
        // Calcular média
        double avg = students.stream()
            .mapToInt(StudentGrade::getScore)
            .average()
            .orElse(0);
        System.out.printf("Média: %.1f%n", avg);
    }
}

❓ Perguntas Frequentes

P: Qual é a capacidade inicial do ArrayList? R: O padrão é 10. Se você souber o tamanho aproximado, especifique-o no construtor para redimensionamento.

P: Qual é o mecanismo de redimensionamento do ArrayList? R: Cada redimensionamento aumenta a capacidade em 1,5 vezes.

P: List pode armazenar null? R: Tanto ArrayList quanto LinkedList podem armazenar null.

📖 Resumo

ArrayList é baseado em array, rápido para consultas, lento para inserções/remoções
LinkedList é baseado em lista encadeada, rápido para inserções/remoções, lento para consultas
Operações comuns: add/get/set/remove/contains/sort
Métodos de travessia: for/for-each/Iterator/Lambda

📝 Exercícios

Desduplicação: Remova elementos duplicados de um ArrayList
Mesclar: Mescle duas Lists ordenadas em uma List ordenada
Contagem: Conte as ocorrências de cada elemento em uma List

Próxima Lição

Na próxima lição, aprenderemos sobre Set e HashSet — entendendo o mecanismo de desduplicação de Set.