Java 8 Spliterator (oder ähnlich), der einen Wert zurückgibt, wenn es nur einen einzigen Wert gibt

Question

Ich bin ein großer Fan des Stream-Operators singleOrEmpty. Es ist nicht in der Standardbibliothek, aber ich finde es sehr nützlich. Wenn ein Stream nur einen einzelnen Wert hat, gibt er diesen Wert in Optional zurück. Wenn es keine Werte oder mehr als einen Wert hat, gibt es Optional.empty() zurück.

Optional<Int> value = someList.stream().{singleOrEmpty} 
[]  -> Optional.empty() 
[1] -> Optional.of(1) 
[1, 1] -> Optional.empty() 
etc. 

I asked a question about it earlier und @ThomasJungblut came up with this great implementation:

public static <T> Optional<T> singleOrEmpty(Stream<T> stream) { 
    return stream.limit(2) 
     .map(Optional::ofNullable) 
     .reduce(Optional.empty(), 
      (a, b) -> a.isPresent()^b.isPresent() ? b : Optional.empty()); 
} 

Das einzige Problem ist, müssen Sie es zu Beginn des Gesprächs am Ende

singleOrEmpty(someList.stream().filter(...).map(...)) 

anstatt nacheinander setzen

someList.stream().filter().map().singleOrEmpty() 

, die es schwieriger zu lesen als andere Stream-Mechanismen macht.

So als Neuling zu dieser Verarbeitung Sachen Strom, hat jemand irgendwelche Tricks, wie ein Kurzschließen singleOrEmpty Mechanismus am Ende eine Folge von Strom Transformationen setzen geht über?

Answer 1

Es wird nicht so schnell wie die Begrenzung (2), aber man kann es als list.stream().filter(...).map(...).collect(singleOrEmpty())

verwenden

static <T> Collector<T, ?, Optional<T>> singleOrEmpty() { 
    return Collectors.collectingAndThen(
      Collectors.mapping(
        Optional::of, 
        Collectors.reducing((a, b) -> Optional.empty()) 
      ), 
      o -> o.orElseGet(Optional::empty) 
    ); 
} 

Stream.empty().collect(singleOrEmpty()); // Optional.empty 
Stream.of(1).collect(singleOrEmpty());  // Optional[1] 
Stream.of(1, 1).collect(singleOrEmpty()); // Optional.empty 
Stream.of(1, 1).skip(1).collect(singleOrEmpty()); // Optional[1] 

Für das, was es wert ist, es sei denn, dies wirklich leistungskritischen Code ist, würde ich persönlich lieber die weniger klug, aber viel klarere Umsetzung

static<T> Collector<T,?,Optional<T>> singleOrEmpty() { 
    return Collectors.collectingAndThen(
      Collectors.toList(), 
      lst -> lst.size() == 1 
        ? Optional.of(lst.get(0)) 
        : Optional.empty() 
    ); 
}