Coleções em Java

List, ArrayList, LinkedList, Ordenação e Busca

Programação Orientada a Objetos

Objetivos da aula

Entender o que são coleções (java.util).
Compreender a interface List e seu uso.
Diferenciar ArrayList e LinkedList.
Realizar operações básicas em listas (add, remove, get...).
Aplicar ordenação com Collections.sort e Comparator.
Realizar busca linear e binária em listas.

Introdução às Coleções

Coleções são estruturas de dados prontas do Java para armazenar e manipular grupos de objetos.

Substituem (em muitos casos) o uso de arrays simples.
Permitem tamanho dinâmico (cresce/diminui conforme necessário).
Oferecem métodos utilitários para:
- Adicionar, remover, buscar, ordenar, etc.

Pacote principal: java.util

Interface List

List é uma coleção ordenada que permite elementos duplicados.

Mantém a ordem de inserção dos elementos.
Permite acesso por índice (0, 1, 2, ...).
Permite elementos repetidos.

Principais implementações:

ArrayList
LinkedList

Exemplo básico com List


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

public class ExemploList {
    public static void main(String[] args) {
        List<String> nomes = new ArrayList<>();

        nomes.add("Ana");
        nomes.add("Pedro");
        nomes.add("Ana"); // permitido repetir

        System.out.println("Tamanho: " + nomes.size());
        System.out.println("Primeiro: " + nomes.get(0));
        System.out.println("Lista completa: " + nomes);
    }
}

ArrayList x LinkedList

ArrayList

Baseado em array dinâmico.
Acesso rápido por índice (get(i)).
Inserções e remoções no meio podem ser mais lentas.
Bom para muitas leituras e iterações.

LinkedList

Baseado em lista duplamente encadeada.
Acesso por índice é mais lento.
Ótimo para inserções/remoções no início/meio.
Útil para implementação de filas e deques.

ArrayList - Exemplo


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

public class ExemploArrayList {
    public static void main(String[] args) {
        List<String> frutas = new ArrayList<>();

        frutas.add("Maçã");
        frutas.add("Banana");
        frutas.add("Laranja");

        frutas.add(1, "Pera"); // insere no índice 1

        System.out.println(frutas); // [Maçã, Pera, Banana, Laranja]
    }
}

LinkedList - Exemplo


import java.util.LinkedList;
import java.util.List;

public class ExemploLinkedList {
    public static void main(String[] args) {
        List<String> tarefas = new LinkedList<>();

        tarefas.add("Estudar Java");
        tarefas.add("Revisar exercícios");
        tarefas.add(0, "Ler anotações"); // inserção no início

        System.out.println(tarefas);
    }
}

Operações básicas em List


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

// adicionar
nomes.add("João");
nomes.add("Maria");

// acessar
String primeiro = nomes.get(0);

// atualizar
nomes.set(1, "Maria Clara");

// remover por valor
nomes.remove("João");

// remover por índice
nomes.remove(0);

// tamanho
int tamanho = nomes.size();

Iterando sobre a List


List<String> nomes = List.of("Ana", "Bruno", "Carlos");

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

// for-each
for (String nome : nomes) {
    System.out.println(nome);
}

Iterando com Iterator


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

public class ExemploIterator {
    public static void main(String[] args) {
        List<String> nomes = new ArrayList<>();
        nomes.add("Ana");
        nomes.add("Bruno");
        nomes.add("Carlos");

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

Ordenação de List (Strings)


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

public class OrdenacaoSimples {
    public static void main(String[] args) {
        List<String> nomes = new ArrayList<>();
        nomes.add("Carlos");
        nomes.add("Ana");
        nomes.add("Beatriz");

        Collections.sort(nomes); // ordem alfabética

        System.out.println(nomes); // [Ana, Beatriz, Carlos]
    }
}

Ordenando objetos - Classe Pessoa


class Pessoa {
    String nome;
    int idade;

    Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    @Override
    public String toString() {
        return nome + " (" + idade + ")";
    }
}

Ordenando objetos com Comparator


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

public class OrdenacaoPessoas {
    public static void main(String[] args) {
        List<Pessoa> pessoas = new ArrayList<>();
        pessoas.add(new Pessoa("Ana", 30));
        pessoas.add(new Pessoa("João", 20));
        pessoas.add(new Pessoa("Beatriz", 25));

        // Por idade crescente
        pessoas.sort(Comparator.comparingInt(p -> p.idade));
        System.out.println("Por idade: " + pessoas);

        // Por nome (alfabético)
        pessoas.sort(Comparator.comparing(p -> p.nome));
        System.out.println("Por nome: " + pessoas);
    }
}

Busca linear em List


List<String> nomes = List.of("Ana", "Bruno", "Carlos");

String alvo = "Bruno";

boolean existe = nomes.contains(alvo);

if (existe) {
    System.out.println(alvo + " está na lista!");
} else {
    System.out.println(alvo + " NÃO está na lista.");
}

Busca linear: percorre a lista do início ao fim.

Busca binária em List

Requer que a lista esteja ordenada.


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

public class BuscaBinaria {
    public static void main(String[] args) {
        List<String> nomes = new ArrayList<>();
        nomes.add("Carlos");
        nomes.add("Ana");
        nomes.add("Beatriz");

        Collections.sort(nomes); // [Ana, Beatriz, Carlos]

        int pos = Collections.binarySearch(nomes, "Beatriz");

        if (pos >= 0) {
            System.out.println("Encontrado no índice: " + pos);
        } else {
            System.out.println("Não encontrado.");
        }
    }
}

ArrayList x LinkedList (Resumo)

Operação	ArrayList	LinkedList
Acesso por índice	Rápido (O(1))	Lento (O(n))
Inserir/remover no fim	Rápido	Rápido
Inserir/remover no meio	Mais lento (realoca/shift)	Mais eficiente
Uso de memória	Mais compacto	Mais overhead (ponteiros)

Atividade 1 - Lista de alunos

Objetivo: praticar criação de ArrayList e ordenação.

Crie um programa que:
- Use ArrayList<String> para armazenar nomes de alunos.
- Leia pelo menos 5 nomes do teclado.
- Ordene os nomes em ordem alfabética.
- Exiba a lista antes e depois da ordenação.

Atividade 2 - Lista de Produtos

Objetivo: trabalhar com listas de objetos e Comparator.

Crie a classe Produto com:
- String nome
- double preco
Crie uma List<Produto> e adicione 5 produtos.
Ordene:
- Por preço (crescente).
- Por nome (alfabético).
Mostre a lista em cada ordenação.

Atividade 3 - Busca em List

Objetivo: praticar busca linear e binária.

Usando a lista de alunos da Atividade 1:
- Peça ao usuário um nome para buscar.
- Verifique se existe usando contains (busca linear).
- Ordene a lista e use Collections.binarySearch.
- Mostre a posição (índice) se for encontrado.

Desafio Final - Carrinho de Compras

Crie um sistema simples de carrinho de compras usando List.

Use a classe Produto (nome, preço).
Permita:
- Adicionar produto ao carrinho.
- Remover produto do carrinho.
- Listar todos os itens.
- Calcular o total da compra.
Permita ordenar por:
- Nome.
- Preço.
Implemente busca por nome no carrinho.

Encerramento

Coleções facilitam o trabalho com grupos de objetos.
List é uma das estruturas mais usadas.
ArrayList x LinkedList: escolha depende do tipo de operação.
Ordenação e busca são operações comuns e essenciais.

Dúvidas? 🤔