Was ist der richtige Weg, um NULL zu überprüfen oder Ausnahmen in einer verketteten Anweisung in Java 8 zu überprüfen?

Question

Zum Beispiel für diesen Code:

List<Class> classes = 
     Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String") 
       .map(className -> Class.forName(className)) 
       .collect(Collectors.toList()); 

Dieser Code läuft jetzt gut. Aber nehmen wir an, wir haben eine leere Liste im Stream und wir haben Tonnen von Operationen für den Stream. Es könnte NullPointer-Ausnahmen und usw. bekommen. Ich finde es auch schwer zu versuchen-fangen für diese Art von Aussage. Was ist der richtige Weg, um eine Ausnahme dafür zu behandeln?

Answer 1

Sie müssen nicht nach Nullen suchen. Wenn Sie einen leeren Stream alle Operationen haben, werden übersprungen:

Stream.of("hello") 
     .filter(e => "world".equals(e)) // empties the stream 
     .foreach(System.out::println); // no NullPointer, no output 

Ausnahmebehandlung ist möglich, in Mapper:

List<Class<?>> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String") 
      .map(className -> { 
       try { 
        return Class.forName(className); 
       } catch (Exception e) { 
        throw new YourRuntimeException(); 
       } 
      }) 
      .collect(Collectors.toList()); 

Wenn Sie Ausnahmen wollen ignoriert werden, dann schlage ich zu Optional s abzubilden.

List<Class<?>> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String") 
      .map(className -> { 
       try { 
        return Optional.of(Class.forName(className)); 
       } catch (Exception e) { 
        return Optional.<Class<?>>empty(); 
       } 
      }) 
      .filter(Optional::isPresent) // ignore empty values 
      .map (Optional::get) // unwrap Optional contents 
      .collect(Collectors.toList()); 

Bitte haben auch einen Blick auf How can I throw CHECKED exceptions from inside Java 8 streams? für eine ausführlichere Diskussion über Class.forName in Kombination mit Java-8-Streams.

Answer 2

Ihre Frage ist ein bisschen seltsam. Sie behaupten "Dieser Code läuft jetzt gut", während es Kompilierzeitfehler generieren sollte, da Sie die geprüfte Ausnahme behandeln, die von Class.forName deklariert wird. Außerdem sprechen Sie über leere Listen, aber in Ihrem Code sind keine Listen beteiligt. Dasselbe gilt für Ihre Referenz auf NullPointerException, da Ihr Code null an keiner Stelle produziert.

Höchstwahrscheinlich sprechen Sie über einen Code, der die ClassNotFoundException fängt und durch die Rückgabe null behandelt. Du solltest das niemals tun. Wenn Sie herausfiltern Ausfälle möchten, können Sie es auf diese Weise tun:

List<Class<?>> classes = 
    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String") 
     .flatMap(className -> { 
       try { 
        return Stream.of(Class.forName(className)); 
       } catch (ClassNotFoundException ex) { 
        // recommended: insert logging statement here 
        return Stream.empty(); 
       } 
      }) 
     .collect(Collectors.toList()); 

Auf diese Weise wird kein Element im Fall einer Ausnahme erzeugt werden, und Sie müssen nicht Downstream Handhabung zusätzlicher Fehler tun.