Comment gérer les exceptions vérifiées émises par les méthodes invoquées dans les expressions Java 8 Lambda ?

Java 8 Lambda-Streams : filtrage par méthode avec exceptions

L'interception des exceptions levées à partir de méthodes invoquées dans les expressions lambda présente un défi lors de l'utilisation de capacités améliorées de traitement de flux Java 8. Le problème se pose lorsque ces méthodes déclarent des exceptions vérifiées, que le lambda englobant n'est pas autorisé à lancer.

Considérons l'exemple suivant :

<code class="java">class Bank {

    public Set<string> getActiveAccountNumbers() throws IOException {
        Stream<account> s = accounts.values().stream();
        s = s.filter(a -> a.isActive());
        Stream<string> ss = s.map(a -> a.getNumber());
        return ss.collect(Collectors.toSet());
    }
}

interface Account {

    boolean isActive() throws IOException;
    String getNumber() throws IOException;
}</string></account></string></code>

Pour compiler ce code, il est nécessaire d'attraper le potentiel IOException dans les méthodes isActive et getNumber. Cependant, la simple gestion des exceptions dans un bloc try-catch, comme démontré ci-dessous, entraîne toujours une erreur de compilation :

<code class="java">class Bank {

    public Set<string> getActiveAccountNumbers() throws IOException {
        try {
            Stream<account> s = accounts.values().stream();
            s = s.filter(a -> a.isActive());
            Stream<string> ss = s.map(a -> a.getNumber());
            return ss.collect(Collectors.toSet());
        } catch (IOException ex) {
            // Exception not caught
        }
    }
}</string></account></string></code>

Pour résoudre ce problème, l'exception doit être capturée avant d'échapper à l'expression lambda. Ceci peut être réalisé en enveloppant le lambda dans une fonction personnalisée qui traduit les exceptions vérifiées en exceptions non vérifiées :

<code class="java">s = s.filter(a -> {
    try {
        return a.isActive();
    } catch (IOException e) {
        throw new UncheckedIOException(e); // Translated to an unchecked exception
    }
});</code>

Alternativement, une approche qui évite l'emballage peut être utilisée :

<code class="java">public static <t> T uncheckCall(Callable<t> callable) {
    try {
        return callable.call();
    } catch (Exception e) {
        sneakyThrow(e); // Potentially throws the exception
        return null; // Unreachable, but necessary to satisfy the compiler
    }
}</t></t></code>

Cette fonction fait essentiellement croire au compilateur qu'aucune exception vérifiée ne peut être levée, permettant à l'exception d'être gérée gracieusement à un niveau supérieur.

<code class="java">return s.filter(a -> uncheckCall(a::isActive))
        .map(Account::getNumber)
        .collect(toSet());</code>

En appliquant ces techniques, il est possible d'utiliser des expressions lambda avec méthodes qui déclarent les exceptions vérifiées, garantissant à la fois la clarté du code et les capacités de gestion des exceptions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!