Dominando Generics em Java: A Aventura da Equipe TechCorp na Criação de um Sistema Robusto

// Código problemático do sistema legacy
public class ProdutoManager {
    private List produtos = new ArrayList(); // Raw type - PERIGO!
    
    public void adicionarProduto(Object produto) {
        produtos.add(produto); // Aceita qualquer objeto
    }
    
    public Object obterProduto(int index) {
        return produtos.get(index); // Retorna Object
    }
}

// O que acontecia no código legacy
ProdutoManager manager = new ProdutoManager();
manager.adicionarProduto(new Produto("Notebook", 2500.00));
manager.adicionarProduto("String inválida"); // Ops! Aceita qualquer coisa
manager.adicionarProduto(12345); // Números também passam

// Na hora de usar...
Produto produto = (Produto) manager.obterProduto(0); // OK
Produto produto2 = (Produto) manager.obterProduto(1); // BOOM! ClassCastException

# Baixar do site oficial Oracle ou usar SDKMAN
curl -s "https://get.sdkman.io" | bash
sdk install java 21.0.1-oracle

java -version
# Deve mostrar: java version "21.0.1"

# Usar Homebrew
brew install openjdk@21
echo 'export PATH="/opt/homebrew/opt/openjdk@21/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

sudo apt update
sudo apt install openjdk-21-jdk
export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64

TechCorpGenerics/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── techcorp/
│   │               ├── model/
│   │               │   ├── Produto.java
│   │               │   └── Usuario.java
│   │               ├── repository/
│   │               │   └── GenericRepository.java
│   │               ├── service/
│   │               │   └── ProdutoService.java
│   │               ├── util/
│   │               │   └── CollectionUtils.java
│   │               └── Main.java
│   └── test/
│       └── java/
└── README.md

// src/main/java/com/techcorp/model/Produto.java
package com.techcorp.model;

public class Produto {
    private Long id;
    private String nome;
    private Double preco;
    private String categoria;
    
    // Construtor padrão
    public Produto() {}
    
    // Construtor com parâmetros
    public Produto(Long id, String nome, Double preco, String categoria) {
        this.id = id;
        this.nome = nome;
        this.preco = preco;
        this.categoria = categoria;
    }
    
    // Getters e Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getNome() { return nome; }
    public void setNome(String nome) { this.nome = nome; }
    
    public Double getPreco() { return preco; }
    public void setPreco(Double preco) { this.preco = preco; }
    
    public String getCategoria() { return categoria; }
    public void setCategoria(String categoria) { this.categoria = categoria; }
    
    // toString para facilitar debugging
    @Override
    public String toString() {
        return String.format("Produto{id=%d, nome='%s', preco=%.2f, categoria='%s'}", 
                           id, nome, preco, categoria);
    }
    
    // equals e hashCode para comparações
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Produto produto = (Produto) obj;
        return id != null && id.equals(produto.id);
    }
    
    @Override
    public int hashCode() {
        return id != null ? id.hashCode() : 0;
    }
}

// src/main/java/com/techcorp/repository/GenericRepository.java
package com.techcorp.repository;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Repository genérico que pode trabalhar com qualquer tipo de entidade
 * @param <T> Tipo da entidade
 * @param <ID> Tipo do identificador
 */
public class GenericRepository<T, ID> {
    
    // Simulando um banco de dados em memória
    private final Map<ID, T> database = new HashMap<>();
    private final Class<T> entityType;
    
    public GenericRepository(Class<T> entityType) {
        this.entityType = entityType;
    }
    
    /**
     * Salva uma entidade no repository
     * @param entity Entidade a ser salva
     * @param id Identificador único
     * @return A entidade salva
     */
    public T save(T entity, ID id) {
        Objects.requireNonNull(entity, "Entidade não pode ser null");
        Objects.requireNonNull(id, "ID não pode ser null");
        
        database.put(id, entity);
        System.out.println("Entidade salva: " + entity);
        return entity;
    }
    
    /**
     * Busca uma entidade pelo ID
     * @param id Identificador da entidade
     * @return Optional contendo a entidade ou empty se não encontrada
     */
    public Optional<T> findById(ID id) {
        Objects.requireNonNull(id, "ID não pode ser null");
        return Optional.ofNullable(database.get(id));
    }
    
    /**
     * Retorna todas as entidades
     * @return Lista com todas as entidades
     */
    public List<T> findAll() {
        return new ArrayList<>(database.values());
    }
    
    /**
     * Remove uma entidade pelo ID
     * @param id Identificador da entidade
     * @return true se removida com sucesso, false caso contrário
     */
    public boolean deleteById(ID id) {
        Objects.requireNonNull(id, "ID não pode ser null");
        T removed = database.remove(id);
        if (removed != null) {
            System.out.println("Entidade removida: " + removed);
            return true;
        }
        return false;
    }
    
    /**
     * Verifica se existe uma entidade com o ID especificado
     * @param id Identificador da entidade
     * @return true se existe, false caso contrário
     */
    public boolean existsById(ID id) {
        Objects.requireNonNull(id, "ID não pode ser null");
        return database.containsKey(id);
    }
    
    /**
     * Conta o número total de entidades
     * @return Número de entidades
     */
    public long count() {
        return database.size();
    }
    
    /**
     * Busca entidades usando um filtro personalizado
     * @param filter Função de filtro
     * @return Lista de entidades que atendem ao filtro
     */
    public List<T> findByFilter(java.util.function.Predicate<T> filter) {
        Objects.requireNonNull(filter, "Filtro não pode ser null");
        return database.values().stream()
                .filter(filter)
                .collect(Collectors.toList());
    }
    
    /**
     * Limpa todos os dados do repository
     */
    public void clear() {
        database.clear();
        System.out.println("Repository limpo para tipo: " + entityType.getSimpleName());
    }
}

// src/main/java/com/techcorp/util/CollectionUtils.java
package com.techcorp.util;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * Utilitários genéricos para trabalhar com coleções
 */
public class CollectionUtils {
    
    /**
     * Método genérico para filtrar uma lista
     * @param <T> Tipo dos elementos da lista
     * @param list Lista a ser filtrada
     * @param predicate Condição de filtro
     * @return Nova lista filtrada
     */
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        Objects.requireNonNull(list, "Lista não pode ser null");
        Objects.requireNonNull(predicate, "Predicate não pode ser null");
        
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
    
    /**
     * Método genérico para transformar uma lista
     * @param <T> Tipo dos elementos da lista original
     * @param <R> Tipo dos elementos da lista resultado
     * @param list Lista original
     * @param mapper Função de transformação
     * @return Nova lista transformada
     */
    public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
        Objects.requireNonNull(list, "Lista não pode ser null");
        Objects.requireNonNull(mapper, "Mapper não pode ser null");
        
        List<R> result = new ArrayList<>();
        for (T item : list) {
            result.add(mapper.apply(item));
        }
        return result;
    }
    
    /**
     * Método genérico para encontrar o primeiro elemento que atende a condição
     * @param <T> Tipo dos elementos da lista
     * @param list Lista a ser pesquisada
     * @param predicate Condição de busca
     * @return Optional com o primeiro elemento encontrado
     */
    public static <T> Optional<T> findFirst(List<T> list, Predicate<T> predicate) {
        Objects.requireNonNull(list, "Lista não pode ser null");
        Objects.requireNonNull(predicate, "Predicate não pode ser null");
        
        for (T item : list) {
            if (predicate.test(item)) {
                return Optional.of(item);
            }
        }
        return Optional.empty();
    }
    
    /**
     * Método genérico para ordenar uma lista
     * @param <T> Tipo dos elementos da lista
     * @param list Lista a ser ordenada
     * @param comparator Comparador para ordenação
     * @return Nova lista ordenada
     */
    public static <T> List<T> sort(List<T> list, Comparator<T> comparator) {
        Objects.requireNonNull(list, "Lista não pode ser null");
        Objects.requireNonNull(comparator, "Comparator não pode ser null");
        
        List<T> result = new ArrayList<>(list);
        result.sort(comparator);
        return result;
    }
    
    /**
     * Método genérico para agrupar elementos de uma lista
     * @param <T> Tipo dos elementos da lista
     * @param <K> Tipo da chave de agrupamento
     * @param list Lista a ser agrupada
     * @param keyExtractor Função para extrair a chave
     * @return Map com os elementos agrupados
     */
    public static <T, K> Map<K, List<T>> groupBy(List<T> list, Function<T, K> keyExtractor) {
        Objects.requireNonNull(list, "Lista não pode ser null");
        Objects.requireNonNull(keyExtractor, "KeyExtractor não pode ser null");
        
        Map<K, List<T>> result = new HashMap<>();
        for (T item : list) {
            K key = keyExtractor.apply(item);
            result.computeIfAbsent(key, k -> new ArrayList<>()).add(item);
        }
        return result;
    }
}

// src/main/java/com/techcorp/service/ProdutoService.java
package com.techcorp.service;

import com.techcorp.model.Produto;
import com.techcorp.repository.GenericRepository;
import com.techcorp.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Service para gerenciar produtos usando Generics avançados
 */
public class ProdutoService {
    
    private final GenericRepository<Produto, Long> produtoRepository;
    
    public ProdutoService() {
        this.produtoRepository = new GenericRepository<>(Produto.class);
    }
    
    /**
     * Método com Upper Bounded Wildcard
     * Aceita listas de Produto ou suas subclasses
     * @param produtos Lista de produtos (ou subclasses)
     */
    public void adicionarProdutos(List<? extends Produto> produtos) {
        Objects.requireNonNull(produtos, "Lista de produtos não pode ser null");
        
        for (Produto produto : produtos) {
            produtoRepository.save(produto, produto.getId());
        }
        System.out.println("Adicionados " + produtos.size() + " produtos");
    }
    
    /**
     * Método com Lower Bounded Wildcard
     * Aceita listas que podem receber Produto ou suas superclasses
     * @param destino Lista de destino
     */
    public void copiarProdutos(List<? super Produto> destino) {
        Objects.requireNonNull(destino, "Lista de destino não pode ser null");
        
        List<Produto> produtos = produtoRepository.findAll();
        destino.addAll(produtos);
        System.out.println("Copiados " + produtos.size() + " produtos para a lista de destino");
    }
    
    /**
     * Método genérico para buscar produtos por critério
     * @param <T> Tipo do valor de busca
     * @param extractor Função para extrair o valor de comparação
     * @param valor Valor a ser comparado
     * @return Lista de produtos encontrados
     */
    public <T> List<Produto> buscarPor(java.util.function.Function<Produto, T> extractor, T valor) {
        Objects.requireNonNull(extractor, "Extractor não pode ser null");
        Objects.requireNonNull(valor, "Valor não pode ser null");
        
        return produtoRepository.findByFilter(produto -> 
            Objects.equals(extractor.apply(produto), valor));
    }
    
    /**
     * Método para demonstrar Type Inference
     * @param produtos Lista de produtos
     * @return Map agrupado por categoria
     */
    public Map<String, List<Produto>> agruparPorCategoria(List<Produto> produtos) {
        // Type inference - não precisa especificar tipos nos <>
        return CollectionUtils.groupBy(produtos, Produto::getCategoria);
    }
    
    /**
     * Método com múltiplos type parameters
     * @param <K> Tipo da chave
     * @param <V> Tipo do valor
     * @param keyExtractor Função para extrair chave
     * @param valueExtractor Função para extrair valor
     * @return Map com chave-valor customizados
     */
    public <K, V> Map<K, V> criarMapCustomizado(
            java.util.function.Function<Produto, K> keyExtractor,
            java.util.function.Function<Produto, V> valueExtractor) {
        
        return produtoRepository.findAll().stream()
                .collect(Collectors.toMap(keyExtractor, valueExtractor));
    }
    
    /**
     * Método com bounded type parameters
     * @param <T> Tipo que deve ser Comparable
     * @param extractor Função para extrair valor comparável
     * @return Produto com maior valor
     */
    public <T extends Comparable<T>> Optional<Produto> buscarMaior(
            java.util.function.Function<Produto, T> extractor) {
        
        return produtoRepository.findAll().stream()
                .max(Comparator.comparing(extractor));
    }
    
    // Métodos auxiliares para demonstração
    public void criarProdutosExemplo() {
        List<Produto> produtos = Arrays.asList(
            new Produto(1L, "Notebook Dell", 2500.0, "Eletrônicos"),
            new Produto(2L, "Mouse Gamer", 150.0, "Eletrônicos"),
            new Produto(3L, "Cadeira Ergonômica", 800.0, "Móveis"),
            new Produto(4L, "Mesa de Escritório", 600.0, "Móveis"),
            new Produto(5L, "Smartphone", 1200.0, "Eletrônicos")
        );
        
        adicionarProdutos(produtos);
    }
    
    public GenericRepository<Produto, Long> getRepository() {
        return produtoRepository;
    }
}

// src/main/java/com/techcorp/Main.java
package com.techcorp;

import com.techcorp.model.Produto;
import com.techcorp.service.ProdutoService;
import com.techcorp.util.CollectionUtils;

import java.util.*;

/**
 * Classe principal demonstrando o uso prático de Generics
 */
public class Main {
    
    public static void main(String[] args) {
        System.out.println("=== TECHCORP GENERICS DEMO ===\n");
        
        // Criando o service
        ProdutoService service = new ProdutoService();
        
        // Demonstração 1: Criando produtos exemplo
        System.out.println("📦 Criando produtos exemplo...");
        service.criarProdutosExemplo();
        System.out.println();
        
        // Demonstração 2: Listando todos os produtos
        System.out.println("📋 Listando todos os produtos:");
        List<Produto> todosProdutos = service.getRepository().findAll();
        todosProdutos.forEach(System.out::println);
        System.out.println();
        
        // Demonstração 3: Buscando produtos por categoria
        System.out.println("🔍 Buscando produtos da categoria 'Eletrônicos':");
        List<Produto> eletronicos = service.buscarPor(Produto::getCategoria, "Eletrônicos");
        eletronicos.forEach(System.out::println);
        System.out.println();
        
        // Demonstração 4: Agrupando produtos por categoria
        System.out.println("📊 Agrupando produtos por categoria:");
        Map<String, List<Produto>> agrupados = service.agruparPorCategoria(todosProdutos);
        agrupados.forEach((categoria, produtos) -> {
            System.out.println("Categoria: " + categoria);
            produtos.forEach(p -> System.out.println("  - " + p.getNome()));
        });
        System.out.println();
        
        // Demonstração 5: Usando CollectionUtils
        System.out.println("🛠️ Usando CollectionUtils:");
        
        // Filtrando produtos caros (> 1000)
        List<Produto> produtosCaros = CollectionUtils.filter(todosProdutos, 
            p -> p.getPreco() > 1000);
        System.out.println("Produtos caros (> R$ 1000):");
        produtosCaros.forEach(p -> System.out.println("  - " + p.getNome() + ": R$ " + p.getPreco()));
        
        // Mapeando para nomes
        List<String> nomes = CollectionUtils.map(todosProdutos, Produto::getNome);
        System.out.println("Nomes dos produtos: " + nomes);
        
        // Ordenando por preço
        List<Produto> ordenadosPorPreco = CollectionUtils.sort(todosProdutos, 
            Comparator.comparing(Produto::getPreco));
        System.out.println("Produtos ordenados por preço:");
        ordenadosPorPreco.forEach(p -> System.out.println("  - " + p.getNome() + ": R$ " + p.getPreco()));
        System.out.println();
        
        // Demonstração 6: Produto mais caro
        System.out.println("💰 Produto mais caro:");
        Optional<Produto> maisCaro = service.buscarMaior(Produto::getPreco);
        maisCaro.ifPresent(p -> System.out.println("  - " + p.getNome() + ": R$ " + p.getPreco()));
        System.out.println();
        
        // Demonstração 7: Map customizado (ID -> Nome)
        System.out.println("🗂️ Map customizado (ID -> Nome):");
        Map<Long, String> mapIdNome = service.criarMapCustomizado(Produto::getId, Produto::getNome);
        mapIdNome.forEach((id, nome) -> System.out.println("  ID " + id + ": " + nome));
        System.out.println();
        
        // Demonstração 8: Wildcards em ação
        System.out.println("🎯 Demonstrando Wildcards:");
        
        // Upper bounded wildcard (? extends Produto)
        List<Produto> novosProdutos = Arrays.asList(
            new Produto(6L, "Teclado Mecânico", 350.0, "Eletrônicos"),
            new Produto(7L, "Monitor 4K", 1800.0, "Eletrônicos")
        );
        service.adicionarProdutos(novosProdutos);
        
        // Lower bounded wildcard (? super Produto)
        List<Object> destinoGenerico = new ArrayList<>();
        service.copiarProdutos(destinoGenerico);
        System.out.println("Elementos copiados para lista genérica: " + destinoGenerico.size());
        System.out.println();
        
        // Demonstração 9: Estatísticas finais
        System.out.println("📈 Estatísticas finais:");
        System.out.println("Total de produtos: " + service.getRepository().count());
        System.out.println("Categorias disponíveis: " + 
            service.agruparPorCategoria(service.getRepository().findAll()).keySet());
        
        // Preço médio
        double precoMedio = service.getRepository().findAll().stream()
            .mapToDouble(Produto::getPreco)
            .average()
            .orElse(0.0);
        System.out.println("Preço médio: R$ " + String.format("%.2f", precoMedio));
        
        System.out.println("\n=== DEMO CONCLUÍDA ===");
    }
}

# No terminal do IntelliJ ou prompt de comando
javac -cp src src/main/java/com/techcorp/Main.java

java -cp src com.techcorp.Main

=== TECHCORP GENERICS DEMO ===

📦 Criando produtos exemplo...
Entidade salva: Produto{id=1, nome='Notebook Dell', preco=2500.00, categoria='Eletrônicos'}
Entidade salva: Produto{id=2, nome='Mouse Gamer', preco=150.00, categoria='Eletrônicos'}
...

public class Container<T> {
    private T conteudo;
    
    // Implementar métodos: set, get, isEmpty, clear
}

public static <T extends Comparable<T>> T findMax(List<T> list) {
    // Sua implementação aqui
}

public static void copy(List<? extends Number> origem, List<? super Number> destino) {
    // Sua implementação aqui
}