Java Stream: Wie übergebe ich Set zu Stream.of() und rufe Methode für jedes Element auf?

Question

Ich habe so im alten Stil Code:

 if (setContainer.getSet() == null) { 
      return null; 
     } 
     for (SetElement setElement : setContainer.getSet()){ 
      if ("SomeString".equals(SetElement.getCode())) { 
       return setElement.getValue(); 
      } 
     } 
     return null; 

ich das versucht habe, aber es funktioniert nicht überprüfen, ob Set null ist:

setContainer.getSet() 
        .stream() 
        .filter(setValue -> "SomeValue".equals(setElement.getCode())) 
        .map(SetElement::getValue) 
        .findAny() 
        .orElse(null) ; 

wie ich verstehen, ich Stream.of() verwenden sollte, aber i dont verstehen, wie Code auszuführen, wie oben, weil es immer Optional<Set<SetElement>> gibt

Answer 1

Sie Optional.ofNullable dies zu erreichen, verwenden können:

return Optional.ofNullable(setContainer.getSet()) 
    .flatMap(set -> set.stream() 
     .filter(e -> "SomeValue".equals(e.getCode())) 
     .map(SetElement::getValue) 
     .findAny()) 
    .orElse(null); 

Answer 2

Sie müssen nicht versuchen, neue Tools anzuwenden, wenn Ihre vorhandenen Tools einwandfrei funktionieren. Wenn Sie also einen Null-Check benötigen, überprüfen Sie es mit if.

set = setContainer.getSet(); 
if(set == null) { 
    return null; 
} else { 
    return mapAndFilter(set); 
} 

Oder mit einem ternären Operator:

Set<T> set = setContainer.getSet(); 
return set == null ? null : mapAndFilter(set); 

Jetzt können Sie mapAndFilter() sauber implementieren, ein Map<T> akzeptieren, die nicht zu null garantiert wird, und ein Map<U> zurück. Es kann durchaus sinnvoll sein, mapAndFilter() mit Streams zu implementieren.

Die Einführung von Optional fügt dem Code unnötige Objekte und unnötige Unordnung hinzu.

Das heißt, es ist besser Stil NULL nie zu vererben, also wenn Sie Ihre setContainer so verbessern können, dass es nie Null zurückgibt (vielleicht kann es eine leere Menge zurückgeben?), Das wäre besser.

Es kann ein guter Kompromiss sein, setContainer Versorgung Optional<Set<T>> zu machen. Aber selbst dann könnten traditionelle Techniken vorzuziehen sein, funktionelle Syntax:

Optional<Set<T>> maybeSet = setContainer.getSet(); 

return maybeSet.isPresent() ? mapAndFilter(maybeSet.get()) : null; 
// vs 
return maybeSet.isPresent() ? mapAndFilter(maybeSet.get()) : Optional.empty(); 
// vs 
return maybeSet.map(mapAndFilterFunction); // might return empty Optional 
// vs 
return maybeSet.map(mapAndFilterFunction).orElse(null); // might return null; 

In diesen mapAndFilter() Verfahren ist. mapAndFilterFunction ist ein Function definiert als Function<Set<T>,Set<U>> mapAndFilterFunction = s -> { ... };