Introdução ao Java Collections Framework

O Java Collections Framework fornece uma arquitetura unificada para armazenar e manipular grupos de objetos. Diferente dos arrays convencionais, as coleções são dinâmicas, permitindo o redimensionamento automático e oferecendo algoritmos otimizados para busca, ordenação e manipulação de dados.

Manipulação Básica com ArrayList

A classe ArrayList é uma implementação da interface List baseada em um array redimensionável. É ideal para situações onde o acesso aleatório aos elementos é frequente.

import java.util.ArrayList;

public class GerenciadorDeDados {
    public ArrayList criarListaMista() {
        // Criando uma instância de ArrayList sem restrição de tipo (Legacy/Object)
        ArrayList colecao = new ArrayList();
        
        // Adicionando diferentes tipos de dados
        colecao.add("https://www.dev-exemplo.com.br");
        colecao.add(2023.99);
        
        return colecao;
    }
}

Operações de CRUD em Listas Dinâmicas

As listas permitem realizar operações fundamentais como inserção, remoção e atualização de elementos através de índices específicos.

import java.util.ArrayList;
import java.util.Scanner;

public class ProcessadorLista {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<String> registros = new ArrayList<>();
        
        int quantidade = input.nextInt();
        for(int i = 0; i < quantidade; i++) {
            registros.add(input.next());
        }

        // Removendo o primeiro e o último registro original
        if (!registros.isEmpty()) {
            registros.remove(0); 
            registros.remove(registros.size() - 1);
        }

        // Adicionando novos valores
        registros.add("novo_item_inicio");
        registros.add("novo_item_final");

        // Atualizando um elemento em posição específica (índice 2)
        if (registros.size() > 2) {
            registros.set(2, "valor_modificado");
        }

        // Iteração e exibição
        registros.forEach(item -> System.out.println(item));
    }
}

Diferenciação entre Estruturas de Dados

Dependendo da necessidade de performance ou comportamento (unicidade, ordenação), diferentes implementações devem ser escolhidas:

• HashSet: Armazena elementos únicos sem garantia de ordem.
• ArrayList: Acesso rápido por índice, permite duplicatas.
• LinkedList: Eficiente para inserções e remoções frequentes no meio da lista.
• HashMap: Armazena pares de chave e valor.

import java.util.*;

public class FabricaColecoes {
    public HashSet<String> gerarSet() {
        HashSet<String> set = new HashSet<>();
        set.add("tecnologia_java");
        return set;
    }

    public ArrayList<String> gerarArrayList() {
        ArrayList<String> list = new ArrayList<>();
        list.add("tecnologia_java");
        return list;
    }

    public HashMap<String, String> gerarMap() {
        HashMap<String, String> mapa = new HashMap<>();
        mapa.put("chave", "tecnologia_java");
        return mapa;
    }
}

Segurança de Tipos com Generics

O uso de Generics garante que uma coleção armazene apenas um tipo específico de dado, evitando erros de ClassCastException em tempo de execução.

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

public class ValidadorTipagem {
    public static void main(String[] args) {
        Scanner leitor = new Scanner(System.in);
        List<String> mensagens = new ArrayList<>();

        for(int i = 0; i < 3; i++) {
            mensagens.add(leitor.next());
        }

        for(int i = 0; i < mensagens.size(); i++) {
            System.out.println("Entrada indexada [" + (i + 1) + "]: " + mensagens.get(i));
        }
    }
}

Gerenciamento de Pares Chave-Valor com Map

A interface Map é essencial para mapear chaves exclusivas para valores específicos, funcionando como um dicionário ou índice de busca rápida.

import java.util.HashMap;
import java.util.Map;

public class SistemaCatalogo {
    public static void main(String[] args) {
        Map<String, Double> produtos = new HashMap<>();
        
        // Inserção de dados
        produtos.put("Notebook", 3500.0);
        produtos.put("Smartphone", 1500.0);
        
        // Recuperação de valor específico
        if(produtos.containsKey("Smartphone")) {
            System.out.println("Preço atual: " + produtos.get("Smartphone"));
        }

        // Atualização de valor
        produtos.put("Smartphone", 1450.0);

        // Remoção de entrada
        produtos.remove("Notebook");

        System.out.println("Catálogo atualizado: " + produtos);
    }
}

Conceitos Teóricos

Em Java, qual classe armazena objetos utilizando o conceito de pares chave-valor?

A resposta correta é HashMap (pertencente ao pacote java.util), pois as outras opções como ArrayList e LinkedList implementam a interface List, que foca em sequências ordenadas de elementos isolados.