Einfachste Möglichkeit, einen Stream aus einer Funktion zu erstellen

Question

Stream<T> basiert auf dem internen Iterationsansatz von Spliterator<T>, der wiederum die Iteration auf boolean tryAdvance(Consumer<? super T> action) Implementierung delegiert. Legen Sie es einfach:

Stream<T>---->Spliterator<T>---->boolean tryAdvance(Consumer<T>)

Also, ich möchte eine Art von Programm haben, die eine Stream<T> von einem Function<Consumer<T>, Boolean> erstellen können. Man beachte, dass Function<Consumer<T>, Boolean> den gleichen Deskriptor boolean tryAdvance(Consumer<T>), d. H. Consumer<T> -> Boolean, hat.

Ich bin für eine Hilfsfunktion wie (aktualisiert nach @ shmosel des comment):

static <T> Stream<T> stream(Predicate<Consumer<? super T>> moveNext) { 
    Spliterator<T> iter = new AbstractSpliterator<T>(Long.MAX_VALUE, 0) { 
     @Override 
     public boolean tryAdvance(Consumer<? super T> action) { 
      return moveNext.test(action); 
     } 
    }; 
    return StreamSupport.stream(iter, false); 
} 

Dies ist die prägnante Art und Weise, die ich, dass die Umsetzung erreichen gefunden. Dennoch mag ich den Gebrauch der anonymen inneren Klasse immer noch nicht. Gibt es eine einfachste Alternative?

Answer 1

Da es kein eingebautes Feature gibt, das eine Funktion akzeptiert, gibt es keine Möglichkeit, einen Typ zu erstellen, obwohl es keine innere Klasse sein muss. Z.B.

public interface SingleFuncStream<T> extends Spliterator<T> { 
    public static <T> Stream<T> stream(SingleFuncStream<T> f) { 
     return StreamSupport.stream(f, false); 
    } 
    @Override default public Spliterator<T> trySplit() { return null; } 
    @Override default public long estimateSize() { return Long.MAX_VALUE; } 
    @Override default public int characteristics() { return ORDERED; } 
} 

, die wie verwendet werden kann,

ListIterator<String> i = Arrays.asList("foo", "bar", "baz").listIterator(3); 
SingleFuncStream.<String>stream(c -> { 
    if(!i.hasPrevious()) return false; 
    c.accept(i.previous()); 
    return true; 
}).forEach(System.out::println); 

Aber jetzt, wo Sie geklärt haben, dass Sie benutzerdefinierte Zwischenoperationen bei der Durchführung der obigen Lösung ist nicht geeignet anstreben. Es könnte besser sein, die andere Alternative zu einer inneren Klasse, einer dedizierten obersten Klasse, zu verwenden.

Die meisten dieser Operationen, wie die von Ihnen erwähnten Beispiele, haben entweder einen Status oder müssen Eigenschaften oder eine komplexere Schätzgröße angeben, die Sie nicht mit einer einzigen Funktion ausdrücken können.