Exercicio 08

src/Generics/Exercicio01/Caixa.java

@@ -0,0 +1,30 @@
+package Generics.Exercicio01;
+
+public class Caixa<T> {
+    private T conteudo;
+
+    public void set( T conteudo) {
+        this.conteudo = conteudo;
+    }
+
+    public T get() {
+        return conteudo;
+    }
+
+    public static void main(String[] args) {
+        // Testando com String
+        Caixa<String> caixaString = new Caixa<>();
+        caixaString.set("Olá, Mundo!");
+        System.out.println("Conteúdo da caixa (String): " + caixaString.get());
+
+        // Testando com Integer
+        Caixa<Integer> caixaInt = new Caixa<>();
+        caixaInt.set(42);
+        System.out.println("Conteúdo da caixa (Integer): " + caixaInt.get());
+
+        // Testando com Double
+        Caixa<Double> caixaDouble = new Caixa<>();
+        caixaDouble.set(3.14159);
+        System.out.println("Conteúdo da caixa (Double): " + caixaDouble.get());
+    }
+}

src/Generics/Exercicio02/ArrayPrinter.java

@@ -0,0 +1,28 @@
+package Generics.Exercicio02;
+
+public class ArrayPrinter {
+    // Método genérico para imprimir array de qualquer tipo
+    public static <T> void printArray(T[] array) {
+        for (T elemento : array) {
+            System.out.print(elemento + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        // Testando com array de Integer
+        Integer[] intArray = {1, 2, 3, 4, 5};
+        System.out.print("Array de Integer: ");
+        printArray(intArray);
+
+        // Testando com array de Double
+        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5};
+        System.out.print("Array de Double: ");
+        printArray(doubleArray);
+
+        // Testando com array de String
+        String[] stringArray = {"Olá", "Mundo", "Java", "Generics"};
+        System.out.print("Array de String: ");
+        printArray(stringArray);
+    }
+}

src/Generics/Exercicio03/Comparavel.java

@@ -0,0 +1,5 @@
+package Generics.Exercicio03;
+
+public interface Comparavel<T> {
+    boolean ehMaiorQue(T outro);
+}

src/Generics/Exercicio03/Produto.java

@@ -0,0 +1,33 @@
+package Generics.Exercicio03;
+
+public class Produto implements Comparavel<Produto> {
+    private String nome;
+    private double preco;
+
+    public Produto(String nome, double preco) {
+        this.nome = nome;
+        this.preco = preco;
+    }
+
+    @Override
+    public boolean ehMaiorQue(Produto outro) {
+        return this.preco > outro.preco;
+    }
+
+    @Override
+    public String toString() {
+        return nome + " (R$ " + String.format("%.2f", preco) + ")";
+    }
+
+    public static void main(String[] args) {
+        Produto produto1 = new Produto("Notebook", 3500.00);
+        Produto produto2 = new Produto("Smartphone", 2500.00);
+
+        System.out.println(produto1 + " é mais caro que " + produto2 + "? " +
+                produto1.ehMaiorQue(produto2));
+
+        System.out.println(produto2 + " é mais caro que " + produto1 + "? " +
+                produto2.ehMaiorQue(produto1));
+    }
+}
+

src/Generics/Exercicio04/MaxFinder.java

@@ -0,0 +1,35 @@
+package Generics.Exercicio04;
+
+import java.util.List;
+
+public class MaxFinder {
+    // Método genérico para encontrar o maior elemento em uma lista de Comparables
+    public static <T extends Comparable<T>> T max(List<T> lista) {
+        if (lista == null || lista.isEmpty()) {
+            throw new IllegalArgumentException("A lista não pode ser nula ou vazia");
+        }
+
+        T max = lista.get(0);
+        for (T elemento : lista) {
+            if (elemento.compareTo(max) > 0) {
+                max = elemento;
+            }
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        // Testando com Integer
+        List<Integer> numeros = List.of(10, 5, 8, 15, 3);
+        System.out.println("Maior número: " + max(numeros));
+
+        // Testando com Double
+        List<Double> decimais = List.of(3.14, 2.71, 1.618, 2.718);
+        System.out.println("Maior decimal: " + max(decimais));
+
+        // Testando com String
+        List<String> palavras = List.of("banana", "abacaxi", "laranja", "uva");
+        System.out.println("Última palavra em ordem alfabética: " + max(palavras));
+    }
+}
+

src/Generics/Exercicio05/Par.java

@@ -0,0 +1,42 @@
+package Generics.Exercicio05;
+
+public class Par<K, V> {
+    private K chave;
+    private V valor;
+
+    public Par(K chave, V valor) {
+        this.chave = chave;
+        this.valor = valor;
+    }
+
+    public K getChave() {
+        return chave;
+    }
+
+    public V getValor() {
+        return valor;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + chave + ": " + valor + "]";
+    }
+
+    public static void main(String[] args) {
+        // Criando uma lista de pares representando alunos (matrícula, nome)
+        java.util.List<Par<Integer, String>> alunos = new java.util.ArrayList<>();
+
+        // Adicionando alguns alunos
+        alunos.add(new Par<>(1001, "Ana Silva"));
+        alunos.add(new Par<>(1002, "Carlos Oliveira"));
+        alunos.add(new Par<>(1003, "Maria Santos"));
+        alunos.add(new Par<>(1004, "João Pereira"));
+
+        // Imprimindo todos os pares
+        System.out.println("Lista de Alunos (Matrícula: Nome):");
+        for (Par<Integer, String> aluno : alunos) {
+            System.out.println(aluno);
+        }
+    }
+}
+

src/Generics/Exercicio06/ImpressorNumeros.java

@@ -0,0 +1,36 @@
+package Generics.Exercicio06;
+
+import java.util.List;
+
+public class ImpressorNumeros {
+    // Método que aceita uma lista de qualquer tipo que seja Number ou seus subtipos
+    public static void imprimirNumeros(List<? extends Number> lista) {
+        for (Number numero : lista) {
+            System.out.print(numero + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        // Testando com lista de Integer
+        List<Integer> inteiros = List.of(1, 2, 3, 4, 5);
+        System.out.print("Lista de Integer: ");
+        imprimirNumeros(inteiros);
+
+        // Testando com lista de Double
+        List<Double> decimais = List.of(1.5, 2.7, 3.1, 4.9);
+        System.out.print("Lista de Double: ");
+        imprimirNumeros(decimais);
+
+        // Testando com lista de Float
+        List<Float> floats = List.of(1.1f, 2.2f, 3.3f, 4.4f);
+        System.out.print("Lista de Float: ");
+        imprimirNumeros(floats);
+
+        // Testando com lista de Long
+        List<Long> longos = List.of(1000L, 2000L, 3000L);
+        System.out.print("Lista de Long: ");
+        imprimirNumeros(longos);
+    }
+}
+

src/Generics/Exercicio07/Pilha.java

@@ -0,0 +1,68 @@
+package Generics.Exercicio07;
+
+import java.util.ArrayList;
+import java.util.EmptyStackException;
+import java.util.List;
+
+public class Pilha<T> {
+    private List<T> elementos;
+    private int topo;
+
+    public Pilha() {
+        this.elementos = new ArrayList<>();
+        this.topo = -1;
+    }
+
+    public void push(T elemento) {
+        elementos.add(elemento);
+        topo++;
+    }
+
+    public T pop() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        T elemento = elementos.get(topo);
+        elementos.remove(topo--);
+        return elemento;
+    }
+
+    public T peek() {
+        if (isEmpty()) {
+            throw new EmptyStackException();
+        }
+        return elementos.get(topo);
+    }
+
+    public boolean isEmpty() {
+        return topo == -1;
+    }
+
+    public int size() {
+        return topo + 1;
+    }
+
+    public static void main(String[] args) {
+        // Testando com Integer
+        System.out.println("=== Testando Pilha de Integer ===");
+        Pilha<Integer> pilhaInt = new Pilha<>();
+        pilhaInt.push(10);
+        pilhaInt.push(20);
+        pilhaInt.push(30);
+        System.out.println("Topo: " + pilhaInt.peek()); // Deve mostrar 30
+        System.out.println("Tamanho: " + pilhaInt.size()); // Deve mostrar 3
+        System.out.println("Removido: " + pilhaInt.pop()); // Deve remover 30
+        System.out.println("Novo topo: " + pilhaInt.peek()); // Deve mostrar 20
+
+        // Testando com String
+        System.out.println("\n=== Testando Pilha de String ===");
+        Pilha<String> pilhaStr = new Pilha<>();
+        pilhaStr.push("Primeiro");
+        pilhaStr.push("Segundo");
+        pilhaStr.push("Terceiro");
+        System.out.println("Topo: " + pilhaStr.peek()); // Deve mostrar "Terceiro"
+        System.out.println("Tamanho: " + pilhaStr.size()); // Deve mostrar 3
+        System.out.println("Removido: " + pilhaStr.pop()); // Deve remover "Terceiro"
+        System.out.println("Novo topo: " + pilhaStr.peek()); // Deve mostrar "Segundo"
+    }
+}

src/Generics/Exercicio08/Cliente.java

@@ -0,0 +1,25 @@
+package Generics.Exercicio08;
+
+public class Cliente {
+    private int id;
+    private String nome;
+    private String email;
+
+    public Cliente(String nome, String email) {
+        this.nome = nome;
+        this.email = email;
+    }
+
+    // Getters e Setters
+    public int getId() { return id; }
+    public void setId(int id) { this.id = id; }
+    public String getNome() { return nome; }
+    public void setNome(String nome) { this.nome = nome; }
+    public String getEmail() { return email; }
+    public void setEmail(String email) { this.email = email; }
+
+    @Override
+    public String toString() {
+        return String.format("Cliente [id=%d, nome=%s, email=%s]", id, nome, email);
+    }
+}

src/Generics/Exercicio08/Produto.java

@@ -0,0 +1,25 @@
+package Generics.Exercicio08;
+
+public class Produto {
+    private int id;
+    private String nome;
+    private double preco;
+
+    public Produto(String nome, double preco) {
+        this.nome = nome;
+        this.preco = preco;
+    }
+
+    // Getters e Setters
+    public int getId() { return id; }
+    public void setId(int 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; }
+
+    @Override
+    public String toString() {
+        return String.format("Produto [id=%d, nome=%s, preco=R$%.2f]", id, nome, preco);
+    }
+}

src/Generics/Exercicio08/Repositorio.java

@@ -0,0 +1,9 @@
+package Generics.Exercicio08;
+
+import java.util.List;
+
+public interface Repositorio<T, ID> {
+    void salvar(T obj);
+    T buscarPorId(ID id);
+    List<T> listarTodos();
+}

src/Generics/Exercicio08/RepositorioCliente.java

@@ -0,0 +1,28 @@
+package Generics.Exercicio08;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class RepositorioCliente extends RepositorioMemoria<Cliente, Integer> {
+
+    @Override
+    public void salvar(Cliente cliente) {
+        cliente.setId(proximoId++);
+        super.salvar(cliente);
+    }
+
+    @Override
+    public Cliente buscarPorId(Integer id) {
+        return itens.stream()
+                .filter(c -> c.getId() == id)
+                .findFirst()
+                .orElse(null);
+    }
+
+    // Método adicional para buscar clientes por nome (exemplo de método específico)
+    public List<Cliente> buscarPorNome(String nome) {
+        return itens.stream()
+                .filter(c -> c.getNome().toLowerCase().contains(nome.toLowerCase()))
+                .collect(Collectors.toList());
+    }
+}

src/Generics/Exercicio08/RepositorioMemoria.java

@@ -0,0 +1,19 @@
+package Generics.Exercicio08;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class RepositorioMemoria<T, ID> implements Repositorio<T, ID> {
+    protected List<T> itens = new ArrayList<>();
+    protected int proximoId = 1;
+
+    @Override
+    public void salvar(T obj) {
+        itens.add(obj);
+    }
+
+    @Override
+    public List<T> listarTodos() {
+        return new ArrayList<>(itens);
+    }
+}