Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

[Projeto] Desafio Lambdas

Resoluções:

**EXERCÍCIO 1: **

package lambda;

public interface OperacaoMultiplicacao {
    int executar(int a, int b);
}
package lambda;

public class Multiplication {
    public static void main(String[] args) {
        OperacaoMultiplicacao operacao = new OperacaoMultiplicacao() {
            @Override
            public int executar(int a, int b) {
                return a * b;
        }
        };
        System.out.println(operacao.executar(5, 3));
    }
}

**EXERCÍCIO 2: **

package lambda.primo;

public interface OperacaoPrimo {
   public boolean verificarPrimo(int n);
}
package lambda.primo;

import java.util.Scanner;

public class Primo {
    public static void main(String[] args) {
        OperacaoPrimo numeroPrimo = n -> {
            if(n <= 1)
                return false;
            for(int i = 2; i <= Math.sqrt(n); i++) {
                if(n % i == 0)
                    return false;
            }
                return true;
        };

        Scanner sc = new Scanner(System.in);
        System.out.println("Digite um número: ");
        int n = sc.nextInt();

        if (numeroPrimo.verificarPrimo(n)){
            System.out.println("O número " + n + " é primo.");
        }  else {
            System.out.println("O número " + n + " não é primo.");
        }
        sc.close();

    }
}

**EXERCÍCIO 3: **

package lambda.string_conversor;

public interface Converte {
    public String converte (String s);
}
package lambda.string_conversor;

public class Conversor {
    public static void main(String[] args) {
        Converte converteParaMaiscula = String::toUpperCase;
        System.out.println(converteParaMaiscula.converte("hello"));
        }
    }

**EXERCÍCIO 4: **

package lambda.reverse;

public interface Verificacao {
    boolean verificarPalindromo(String str);
}
package lambda.reverse;

public class Palindromo {
    public static void main(String[] args) {
        Verificacao palindromo = str -> str.equals(new StringBuilder(str).reverse().toString());
        System.out.println(palindromo.verificarPalindromo("radar"));
        System.out.println(palindromo.verificarPalindromo("java"));
    }
}

**EXERCÍCIO 5: **

package lambda.replace_all;

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

public class MultiplicaPor3 {
    public static void main(String[] args) {
        List<Integer> numeros = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        numeros.replaceAll(x -> x * 3);

        System.out.println(numeros);
    }
}

**EXERCÍCIO 6: **

package lambda.sort;

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

public class OrdemAlfabetica {
    public static void main(String[] args) {
        List<String> lista = new ArrayList<>(List.of("Avião", "Cachorro", "Montanha", "Garrafa", "Brinquedo"));
        lista.sort((a, b) -> a.compareTo(b));
        System.out.println(lista);
    }
}

**EXERCÍCIO 7: **

package lambda.arithmetic_exception;

public interface Operacao {
    int executar (int a, int b) throws ArithmeticException;
}
package lambda.arithmetic_exception;

public class Divisor {
    public static void main(String[] args) {
        Operacao divisor = (a, b) -> {
            if (b == 0) throw new ArithmeticException("Divisão igual a zero");
            return a / b;
        };

        try {
            System.out.println(divisor.executar(10, 2));
            System.out.println(divisor.executar(10, 0));
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
}
1 resposta

Oi, Luan! Tudo bem?

Excelente entrega no desafio de lambdas, você cobriu os sete exercícios e ainda organizou cada um em seu próprio pacote, o que deixa a leitura bem clara.

Um ponto importante está no exercício 1: ele foi resolvido com uma classe anônima, que é justamente a forma verbosa que a lambda veio substituir. Como OperacaoMultiplicacao tem um único método abstrato, o corpo inteiro cabe em uma linha: OperacaoMultiplicacao operacao = (a, b) -> a * b;. A dica é anotar a interface com @FunctionalInterface, o compilador passa a garantir que ela continue com apenas um método abstrato, e qualquer alteração que quebre esse contrato vira erro na hora em vez de surpresa depois.

Vale olhar também o exercício 6: (a, b) -> a.compareTo(b) pode virar a referência de método String::compareTo, ou ficar ainda mais direto com lista.sort(Comparator.naturalOrder()), seguindo a mesma linha que você já aplicou muito bem no exercício 3 com String::toUpperCase.

Já que você usou replaceAll e sort diretamente nas listas, como acha que esses mesmos exercícios ficariam se fossem resolvidos com streams em vez de modificar a coleção original?

Conteúdos relacionados
Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!