Gibt es eine Möglichkeit, einen Stream wiederzuverwenden?

Wenn Sie wollen, um die Wirkung der Wiederverwendung eines Baches, könnten Sie wickeln den stream Ausdruck in einer Anbieter-und call - myStreamSupplier.get() Wann immer Sie wollen eine neue. Zum Beispiel:

Supplier<Stream<String>> sup = () -> someList.stream();
List<String> nonEmptyStrings = sup.get().filter(s -> !s.isEmpty()).collect(Collectors.toList());
Set<String> uniqueStrings = sup.get().collect(Collectors.toSet());

InformationsquelleAutor der Antwort Hank D

Die ganze Idee mit dem Stream ist, dass es einmal aus. Dies ermöglicht Ihnen das erstellen von nicht-reenterable Quellen (zum Beispiel, liest die Zeilen von der Netzwerk-Verbindung), ohne Zwischenlagerung. Wenn Sie jedoch möchten, dass die Wiederverwendung der Stream-Inhalte, Sie können es dump in die fortgeschrittene Sammlung, um die "hard copy":

Stream<MyType> stream = //get the stream from somewhere
List<MyType> list = stream.collect(Collectors.toList()); //materialize the stream contents
list.stream().doSomething //create a new stream from the list
list.stream().doSomethingElse //create one more stream from the list

Wenn Sie nicht wollen, zu materialisieren stream, in einigen Fällen gibt es Möglichkeiten, um verschiedene Dinge zu tun, die mit den gleichen stream auf einmal. Zum Beispiel, können Sie finden diese oder diese Frage für details.

InformationsquelleAutor der Antwort Tagir Valeev

Als andere haben darauf hingewiesen, die Richtung selbst kann nicht wiederverwendet werden.

Aber eine Möglichkeit um den Effekt der Wiederverwendung ein stream ist zu extrahieren Sie die stream-creation code, um eine Funktion.

Können Sie dies tun, indem Sie eine Methode oder ein function-Objekt, welches den Datenstrom erstellen code. Sie können dann verwenden Sie es mehrmals.

Beispiel:

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

    //The normal way to use a stream:
    List<String> result1 = list.stream()
        .filter(i -> i % 2 == 1)
        .map(i -> i * i)
        .limit(10)
        .map(i -> "i :" + i)
        .collect(toList());

    //The stream operation can be extracted to a local function to
    //be reused on multiple sources:
    Function<List<Integer>, List<String>> listOperation = l -> l.stream()
        .filter(i -> i % 2 == 1)
        .map(i -> i * i)
        .limit(10)
        .map(i -> "i :" + i)
        .collect(toList());

    List<String> result2 = listOperation.apply(list);
    List<String> result3 = listOperation.apply(Arrays.asList(1, 2, 3));

    //Or the stream operation can be extracted to a static method,
    //if it doesn't refer to any local variables:
    List<String> result4 = streamMethod(list);

    //The stream operation can also have Stream as argument and return value,
    //so that it can be used as a component of a longer stream pipeline:
    Function<Stream<Integer>, Stream<String>> streamOperation = s -> s
        .filter(i -> i % 2 == 1)
        .map(i -> i * i)
        .limit(10)
        .map(i -> "i :" + i);

    List<String> result5 = streamOperation.apply(list.stream().map(i -> i * 2))
        .filter(s -> s.length() < 7)
        .sorted()
        .collect(toCollection(LinkedList::new));
}

public static List<String> streamMethod(List<Integer> l) {
    return l.stream()
        .filter(i -> i % 2 == 1)
        .map(i -> i * i)
        .limit(10)
        .map(i -> "i :" + i)
        .collect(toList());
}

Wenn auf der anderen Seite, haben Sie einen stream, die Sie wollen, Durchlaufen Sie mehrere Male, dann müssen Sie speichern den Inhalt des Datenstroms in einigen Sammel-Objekt.

Dann kann man mehrere streams mit dem gleichen Inhalt als Sammlung.

Beispiel:

public void test(Stream<Integer> stream) {
    //Create a copy of the stream elements
    List<Integer> streamCopy = stream.collect(toList());

    //Use the copy to get multiple streams
    List<Integer> result1 = streamCopy.stream() ...
    List<Integer> result2 = streamCopy.stream() ...
}

InformationsquelleAutor der Antwort Lii