Comment gérer les exceptions vérifiées lors de l'utilisation d'expressions Lambda avec des flux dans Java 8 ?

Java 8 : Lambda-Streams, filtration par méthode avec gestion des exceptions

En Java 8, les expressions lambda dans les flux filtrent efficacement les éléments. Cependant, lorsqu'il s'agit de méthodes qui génèrent des exceptions vérifiées comme IOException, des complications peuvent survenir.

L'extrait de code suivant illustre ce problème :

<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;
}</code>

Ce code ne parvient pas à se compiler car il ne peut pas gérer le IOException levée par les méthodes isActive et getNumber dans les expressions lambda.

Pour résoudre ce problème, nous devons intercepter l'exception avant qu'elle n'échappe au lambda :

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

Comme le lambda est évalué dans un contexte différent où l'exception vérifiée n'est pas déclarée, nous enveloppons l'exception vérifiée dans une exception non vérifiée.

Vous pouvez également utiliser une méthode qui désamorce la vérification des exceptions du compilateur :

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

Où uncheckCall est défini comme :

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

Cette méthode convertit efficacement les exceptions vérifiées en exceptions non vérifiées. Cependant, il doit être utilisé avec prudence, car il peut entraîner un comportement inattendu s'il n'est pas géré correctement.

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!