Comment gérer les exceptions dans les expressions Java 8 Lambda lors du filtrage des flux ?

Java 8 : Lambda-Streams - Filtrage par méthode qui génère des exceptions

Les expressions lambda de Java 8 offrent des moyens puissants de manipuler et de traiter les données. Cependant, lorsqu'il s'agit de méthodes capables de lever des exceptions, il est important de connaître les limites des expressions lambda et d'explorer des solutions efficaces.

Le problème :

Considérez le code suivant fragment :

<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 en raison des exceptions vérifiées levées par les méthodes isActive et getNumber. Il ne suffit pas de simplement intercepter les exceptions dans un bloc try-catch environnant, car les exceptions ne sont pas correctement gérées dans les expressions lambda.

La solution :

Pour surmonter ce problème, nous devons intercepter les exceptions avant qu'elles échappent à l'expression lambda. Une approche consiste à utiliser une exception non vérifiée, comme le montre le fragment de code modifié suivant :

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

Ici, nous captons l'exception IOException dans le lambda et lançons une exception non vérifiée, garantissant qu'elle est correctement gérée dans le lambda. expression.

Alternativement, nous pouvons utiliser une méthode wrapper qui traduit les exceptions vérifiées en exceptions non vérifiées :

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

public static <T> T uncheckCall(Callable<T> callable) {
    try {
        return callable.call();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}</code>

Cela nous permet d'envelopper l'expression lambda dans un appel à uncheckCall, qui gère le vérifié les exceptions en interne, laissant l'expression lambda libre de déclarations d'exception vérifiées.

Autres considérations :

Il est important d'être conscient du fait que certaines exceptions peuvent toujours échapper au expression lambda, même avec les solutions suggérées. Par exemple, les exceptions levées lors de l'évaluation de l'opération de collecte se propageront toujours hors du lambda.

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!