Wie gehe ich mit geprüften Ausnahmen um, die von Methoden ausgelöst werden, die in Java 8 Lambda-Ausdrücken aufgerufen werden?

Java 8 Lambda-Streams: Filtern nach Methode mit Ausnahmen

Das Abfangen von Ausnahmen, die von Methoden ausgelöst werden, die in Lambda-Ausdrücken aufgerufen werden, stellt eine Herausforderung bei der Verwendung dar Erweiterte Java 8-Stream-Verarbeitungsfunktionen. Das Problem tritt auf, wenn diese Methoden geprüfte Ausnahmen deklarieren, die das einschließende Lambda nicht auslösen darf.

Betrachten Sie das folgende Beispiel:

<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>

Um diesen Code zu kompilieren, ist es notwendig, zu fängen die potenzielle IOException in den Methoden isActive und getNumber. Allerdings führt die bloße Behandlung der Ausnahmen innerhalb eines Try-Catch-Blocks, wie unten gezeigt, immer noch zu einem Kompilierungsfehler:

<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>

Um dieses Problem zu beheben, muss die Ausnahme erfasst werden, bevor sie dem Lambda-Ausdruck entkommt. Dies kann erreicht werden, indem das Lambda in eine benutzerdefinierte Funktion eingeschlossen wird, die die geprüften Ausnahmen in ungeprüfte übersetzt:

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

Alternativ kann ein Ansatz verwendet werden, der das Umschließen vermeidet:

<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>

Diese Funktion täuscht den Compiler im Wesentlichen vor, dass keine geprüften Ausnahmen ausgelöst werden können, wodurch die Ausnahme auf einer höheren Ebene ordnungsgemäß behandelt werden kann.

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

Durch die Anwendung dieser Techniken ist es möglich, Lambda-Ausdrücke mit zu verwenden Methoden, die geprüfte Ausnahmen deklarieren und so sowohl Codeklarheit als auch Möglichkeiten zur Ausnahmebehandlung gewährleisten.

Das obige ist der detaillierte Inhalt vonWie gehe ich mit geprüften Ausnahmen um, die von Methoden ausgelöst werden, die in Java 8 Lambda-Ausdrücken aufgerufen werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!