Java 8 Spliterator (lub podobny), który zwraca wartość iff jest tylko jedna wartość

Question

Jestem wielkim fanem operatora strumienia singleOrEmpty. Nie ma go w std lib, ale uważam, że jest bardzo użyteczny. Jeśli strumień ma tylko jedną wartość, zwraca tę wartość w postaci Optional. Jeśli nie ma wartości lub więcej niż jedną wartość, zwraca Optional.empty().

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

I asked a question about it earlier i @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()); 
} 

Jedynym problemem jest to, trzeba umieścić go na początku rozmowy

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

zamiast kolejno na końcu

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

co sprawia, że ​​trudniej jest go odczytać niż inne mechanizmy strumieniowe.

Więc jak nowo narodzony w tym strumieniu przetwarzania rzeczy, czy ktoś ma żadnych sztuczek, jak go o oddanie Zwarcie singleOrEmpty mechanizmu na końcu sekwencji przemian strumienia ?

Answer 1

To nie będzie tak szybki jak jeden z limitem (2), ale można go używać jako list.stream().filter(...).map(...).collect(singleOrEmpty())

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] 

Na co warto, chyba że jest to naprawdę wydajność kod krytyczny, ja osobiście wolę mniej mądry, ale znacznie jaśniejsze wdrożenie

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