Comment puis-je gérer les exceptions vérifiées émises par Java 8 Lambdas et Streams ?

Lancement d'exceptions vérifiées à partir de Java 8 Lambdas et Streams

Contrairement aux exceptions d'exécution, les exceptions vérifiées nécessitent une gestion explicite dans le code Java. Cependant, lors de l'utilisation d'expressions et de flux lambda, les développeurs peuvent rencontrer des difficultés pour lancer des exceptions vérifiées. Cet article explore les limitations et les solutions potentielles pour gérer les exceptions vérifiées dans ces contextes.

La limitation :

La syntaxe Java 8 actuelle ne fournit pas de mécanisme direct pour lancer la vérification exceptions provenant des expressions lambda utilisées dans les flux. L'extrait de code suivant illustre l'erreur de compilation rencontrée :

import java.util.List;
import java.util.stream.Stream;

public class CheckedStream {
    public List<Class> getClasses() throws ClassNotFoundException {
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());
    }
}

Le problème vient du fait que les interfaces fonctionnelles utilisées dans les flux, telles que Function et Stream, ne déclarent pas de paramètres de type pour prendre en charge le lancement d'exceptions vérifiées. Par conséquent, le compilateur ne peut pas déduire le type d'exception précis et signale une erreur de compilation.

Le dilemme Oracle :

L'omission de cette fonctionnalité est attribuée à un oubli lors de la conception des interfaces fonctionnelles de Java 8. La communauté Java a largement critiqué Oracle pour cette limitation, beaucoup affirmant qu'il s'agit d'un bug important dans l'API et d'un inconvénient des exceptions vérifiées en général.

Alternatives et solutions de contournement :

Bien que Java 8 ne prenne pas directement en charge le lancement d'exceptions vérifiées à partir de lambdas, il existe des solutions de contournement disponible :

1. Encapsulation des exceptions vérifiées dans les exceptions d'exécution :

Cette approche consiste à envelopper les exceptions vérifiées dans des exceptions d'exécution, puis à lancer les exceptions encapsulées dans des expressions lambda.

// Import the necessary class.
import java.io.IOException;

// Create a wrapper class to wrap checked exceptions.
public class CheckedExceptionWrapper {

    public static void main(String[] args) {
        // Create a stream of strings.
        Stream<String> stream = Stream.of("file1.txt", "file2.txt", "file3.txt");

        // Map the stream using a lambda that wraps checked exceptions.
        stream = stream.map(file -> {
            try {
                // Read the file.
                FileReader reader = new FileReader(file);
                reader.close();
                return file;
            } catch (IOException e) {
                // Wrap the checked exception in a runtime exception.
                throw new RuntimeException(e);
            }
        });

        // Collect the results.
        List<String> files = stream.collect(Collectors.toList());
    }
}

2. Utilisation du fournisseur vérifié :

L'interface CheckedSupplier de la bibliothèque guava vous permet de créer des fournisseurs qui génèrent des exceptions vérifiées. Vous pouvez utiliser cette interface pour envelopper le code de lancement d'exceptions vérifié dans des expressions lambda.

// Import the necessary class.
import com.google.common.base.CheckedSupplier;

// Create a checked supplier that throws a checked exception.
CheckedSupplier<String> supplier = () -> {
    // Code that throws a checked exception.
    throw new RuntimeException();
};

// Get the result from the supplier.
try {
    String result = supplier.get();
} catch (Exception e) {
    // Handle the exception.
}

3. Réécriture du code pour éviter d'utiliser des exceptions vérifiées :

Au lieu d'utiliser des exceptions vérifiées, envisagez de réécrire votre code pour gérer les erreurs d'une manière différente. Par exemple, vous pouvez utiliser la classe Optionnel pour représenter des valeurs facultatives ou lancer des exceptions non vérifiées et les gérer à l'aide de blocs try-catch.

4. Utilisation des blocs Catch and Throw :

Cette approche est simple mais peut rendre votre code verbeux et difficile à lire.

// Example for Java 7 with try/catch
try {
    // Code that throws a checked exception.
    throw new RuntimeException();
} catch (Exception e) {
    // Handle the exception.
}

Conclusion :

Bien que la syntaxe de Java 8 ne prenne pas directement en charge le lancement d'exceptions vérifiées à partir des lambdas et des flux, des solutions de contournement sont disponibles. Réfléchissez attentivement à l'approche appropriée à votre situation spécifique.

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!