Wie kann ich mit geprüften Ausnahmen umgehen, die von Java 8-Lambdas und -Streams ausgelöst werden?

Auslösen von geprüften Ausnahmen aus Java 8 Lambdas und Streams

Im Gegensatz zu Laufzeitausnahmen erfordern geprüfte Ausnahmen eine explizite Behandlung im Java-Code. Bei der Verwendung von Lambda-Ausdrücken und -Streams kann es für Entwickler jedoch zu Problemen beim Auslösen geprüfter Ausnahmen kommen. In diesem Artikel werden die Einschränkungen und möglichen Lösungen für den Umgang mit geprüften Ausnahmen in diesen Kontexten untersucht.

Die Einschränkung:

Die aktuelle Java 8-Syntax bietet keinen direkten Mechanismus zum Auslösen von geprüften Ausnahmen Ausnahmen innerhalb von Lambda-Ausdrücken, die in Streams verwendet werden. Der folgende Codeausschnitt veranschaulicht den aufgetretenen Kompilierungsfehler:

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());
    }
}</class>

Das Problem ergibt sich aus der Tatsache, dass die in Streams verwendeten Funktionsschnittstellen wie Funktion und Stream keine Typparameter deklarieren, um das Auslösen geprüfter Ausnahmen zu unterstützen. Folglich kann der Compiler den genauen Ausnahmetyp nicht ableiten und meldet einen Kompilierungsfehler.

Das Oracle-Dilemma:

Das Auslassen dieser Funktionalität wird auf ein Versehen während des zurückgeführt Design der funktionalen Schnittstellen von Java 8. Die Java-Community hat Oracle für diese Einschränkung vielfach kritisiert, wobei viele argumentieren, dass es sich um einen erheblichen Fehler in der API und einen Nachteil von geprüften Ausnahmen im Allgemeinen handelt.

Alternativen und Problemumgehungen:

Während Java 8 das Auslösen geprüfter Ausnahmen von Lambdas nicht direkt unterstützt, gibt es Problemumgehungen verfügbar:

1. Geprüfte Ausnahmen in Laufzeitausnahmen einschließen:

Dieser Ansatz beinhaltet das Einschließen geprüfter Ausnahmen in Laufzeitausnahmen und das anschließende Auslösen der umschlossenen Ausnahmen in Lambda-Ausdrücken.

// 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());
    }
}</string></string>

2. Verwendung von „Checked Supplier“:

Mit der CheckedSupplier-Schnittstelle aus der Guava-Bibliothek können Sie Lieferanten erstellen, die geprüfte Ausnahmen auslösen. Sie können diese Schnittstelle verwenden, um geprüften Code, der Ausnahmen auslöst, in Lambda-Ausdrücke zu verpacken.

// 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.
}</string>

3. Code neu schreiben, um die Verwendung geprüfter Ausnahmen zu vermeiden:

Anstatt geprüfte Ausnahmen zu verwenden, sollten Sie Ihren Code neu schreiben, um Fehler auf andere Weise zu behandeln. Beispielsweise könnten Sie die Klasse „Optional“ verwenden, um optionale Werte darzustellen oder ungeprüfte Ausnahmen auszulösen und sie mithilfe von Try-Catch-Blöcken zu behandeln.

4. Verwenden von Catch- und Throw-Blöcken:

Dieser Ansatz ist unkompliziert, kann jedoch dazu führen, dass Ihr Code ausführlich und schwer lesbar wird.

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

Fazit:

Während die Syntax von Java 8 das Auslösen geprüfter Ausnahmen von Lambdas und Streams nicht direkt unterstützt, sind Problemumgehungen verfügbar. Überlegen Sie sorgfältig, welcher Ansatz für Ihre spezifische Situation geeignet ist.

Das obige ist der detaillierte Inhalt vonWie kann ich mit geprüften Ausnahmen umgehen, die von Java 8-Lambdas und -Streams ausgelöst werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!