Lance uma exceção de dentro de uma expressão lambda

Lançamento de Exceções em Lambdas

• Uma expressão lambda pode lançar exceções.
• Para exceções verificadas (checked exceptions):
• A exceção lançada deve ser compatível com as listadas na cláusula throws do método abstrato da interface funcional.

Requisitos para Exceções Verificadas

• Se a lambda lança uma exceção verificada (por exemplo, IOException):
• O método abstrato da interface funcional deve incluir a mesma exceção na cláusula throws.
• Sem essa cláusula, a expressão lambda será incompatível com o método e causará erro de compilação.

Exemplo: Lançamento de Exceção em Lambda
Código:

import java.io.*;

interface MyIOAction {
    boolean ioAction(Reader rdr) throws IOException;
}

class LambdaExceptionDemo {
    public static void main(String args[]) {
        // Esta lambda de bloco pode lançar uma IOException.
        // A cláusula throws deve estar presente em ioAction().
        MyIOAction myIO = (rdr) -> {
            int ch = rdr.read(); // Pode lançar IOException
            // Lógica adicional pode ser inserida aqui
            return true;
        };
    }
}

Explicação:
Cláusula throws:

• O método ioAction(Reader rdr) na interface funcional MyIOAction inclui throws IOException.
• Isso permite que a lambda associada ao método use operações que podem lançar IOException, como rdr.read().

Erro sem a Cláusula throws:

• Se a cláusula throws IOException for removida de ioAction, o programa não compila.
• Isso ocorre porque a exceção lançada pela lambda (IOException) não é tratada nem declarada no método.

Observação Importante:

• Compatibilidade entre Lambdas e Interfaces Funcionais:
• Uma expressão lambda deve ser compatível com o método abstrato da interface funcional.
• Para exceções verificadas, essa compatibilidade exige que as exceções lançadas pela lambda sejam listadas na cláusula throws do método.

Teste Prático:
Tente remover a cláusula throws de ioAction no código acima. Isso resultará em erro de compilação devido à incompatibilidade entre a lambda e o método da interface funcional.