Dodanie dwóch strumieni Java 8 lub dodatkowego elementu do strumienia

Niestety ta odpowiedź jest prawdopodobnie mało pomocna lub wcale, ale zrobiłem analizę kryminalistyczną listy dyskusyjnej Java Lambda, aby sprawdzić, czy mogę znaleźć przyczynę tego projektu. Tego się dowiedziałem.

Na początku istniała metoda instancyjna dla Stream.concat (Stream)

Na liście dyskusyjnej wyraźnie widzę, że metoda została pierwotnie zaimplementowana jako metoda instancyjna, co można przeczytać w w tym wątku Paula Sandoza, o concat operacja.

W nim omawiają kwestie, które mogą wyniknąć z tych przypadków, w których strumień może być nieskończony i co oznacza konkatenacja w tych przypadkach, ale nie sądzę, że był to powód modyfikacji.

Widzisz w ten drugi wątek , że niektórzy pierwsi użytkownicy JDK 8 pytali o zachowanie metody instancji concat, gdy jest używana z argumentami null.

Ten inny wątek ujawnia jednak, że konstrukcja metoda concat była przedmiotem dyskusji.

Refakturowane do strumieni.concat (strumień,strumień)

Ale bez żadnego wyjaśnienia, nagle, metody zostały zmienione na metody statyczne, jak widać w ten wątek o łączeniu strumieni. Jest to chyba jedyny wątek pocztowy, który rzuca trochę światła na temat tej zmiany, ale nie było wystarczająco jasne dla mnie, aby określić powód refaktoryzacji. Ale widzimy, że zrobili commit , w którym zasugerowali aby przenieść metodę concat z Stream i do klasy pomocniczej Streams.

Refakturowany do strumienia.concat (strumień,strumień)

Później, został przeniesiony ponownie z Streams do Stream, ale po raz kolejny, nie ma na to wyjaśnienia.

Podsumowując, powód projektu nie jest dla mnie do końca jasny i nie mogłem znaleźć dobrego wyjaśnienia. Myślę, że nadal możesz zadać pytanie na liście mailingowej.

Kilka alternatyw dla Stream Konkatenacja

This other thread by Michael Hixson omawia / pyta o inne sposoby łączenia / łączenia strumieni

1. Aby połączyć dwa strumienie, powinienem zrobić to:

   Stream.concat(s1, s2)
   

   Nie to:

   Stream.of(s1, s2).flatMap(x -> x)
   

   ... prawda?

2. Aby połączyć więcej niż dwa strumienie, powinienem zrobić to:

   Stream.of(s1, s2, s3, ...).flatMap(x -> x)
   

   Nie to:

   Stream.of(s1, s2, s3, ...).reduce(Stream.empty(), Stream::concat)
   

   ... prawda?

My StreamEx biblioteka rozszerza funkcjonalność Stream API. W szczególności oferuje metody takie jak append i prepend , które rozwiązują ten problem (wewnętrznie używają concat). Metody te mogą przyjmować inną tablicę stream lub collection lub varargs. Korzystając z mojej biblioteki twój problem można rozwiązać w ten sposób (zauważ, że x != 0 wygląda dziwnie dla nie-prymitywnego strumienia):

Stream<Integer> stream = StreamEx.of(stream1)
             .filter(x -> !x.equals(0))
             .append(stream2)
             .filter(x -> !x.equals(1))
             .append(element)
             .filter(x -> !x.equals(2));

Przy okazji jest też skrót do twojej operacji filter:

Stream<Integer> stream = StreamEx.of(stream1).without(0)
                                 .append(stream2).without(1)
                                 .append(element).without(2);

Po prostu zrób:

Stream.of(stream1, stream2, Stream.of(element)).flatMap(identity());

Gdzie identity() jest statycznym importem Function.identity().

Połączenie wielu strumieni w jeden strumień jest tym samym, co spłaszczenie strumienia.

Jednak, niestety, z jakiegoś powodu nie ma flatten() metody na Stream, więc musisz użyć flatMap() z funkcją tożsamościową.

Możesz użyć Guava ' S Streams.concat(Stream<? extends T>... streams) metoda, która będzie bardzo krótka przy imporcie statycznym:

Stream stream = concat(stream1, stream2, of(element));

Jeśli nie masz nic przeciwko użyciu bibliotek zewnętrznych cyclops-react ma rozszerzony Typ strumienia, który pozwoli Ci to zrobić za pomocą operatorów append / prepend.

Poszczególne wartości, tablice, iteraby, strumienie lub reactive-streams mogą być dodawane i poprzedzane jako metody instancji.

Stream stream = ReactiveSeq.of(1,2)
                           .filter(x -> x!=0)
                           .append(ReactiveSeq.of(3,4))
                           .filter(x -> x!=1)
                           .append(5)
                           .filter(x -> x!=2);

[Disclosure I am the lead developer of cyclops-react]

Może napiszesz własną metodę concat?

public static Stream<T> concat(Stream<? extends T> a, 
                               Stream<? extends T> b, 
                               Stream<? extends T> args)
{
    Stream<T> concatenated = Stream.concat(a, b);
    for (Stream<T> stream : args)
    {
        concatenated = Stream.concat(concatenated, stream);
    }
    return concatenated;
}

To przynajmniej sprawia, że twój pierwszy przykład jest o wiele bardziej czytelny.

Na koniec dnia nie interesuje mnie łączenie strumieni, ale uzyskanie połączonego wyniku przetwarzania każdego elementu wszystkich tych strumieni.

Podczas gdy łączenie strumieni może okazać się kłopotliwe( tak więc ten wątek), łączenie ich wyników przetwarzania jest dość łatwe.

Kluczem do rozwiązania jest stworzenie własnego kolektora i upewnienie się, że funkcja dostawcy dla nowego kolektora zwraca za każdym razem tę samą kolekcję (nie nową ), poniższy kod ilustruje to podejście.

package scratchpad;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CombineStreams {
    public CombineStreams() {
        super();
    }

    public static void main(String[] args) {
        List<String> resultList = new ArrayList<>();
        Collector<String, List<String>, List<String>> collector = Collector.of(
                () -> resultList,
                (list, item) -> {
                    list.add(item);
                },
                (llist, rlist) -> {
                    llist.addAll(rlist);
                    return llist;
                }
        );
        String searchString = "Wil";

        System.out.println("After processing first stream\n"
                + createFirstStream().filter(name -> name.contains(searchString)).collect(collector));
        System.out.println();

        System.out.println("After processing second stream\n"
                + createSecondStream().filter(name -> name.contains(searchString)).collect(collector));
        System.out.println();

        System.out.println("After processing third stream\n"
                + createThirdStream().filter(name -> name.contains(searchString)).collect(collector));
        System.out.println();

    }

    private static Stream<String> createFirstStream() {
        return Arrays.asList(
                "William Shakespeare",
                "Emily Dickinson",
                "H. P. Lovecraft",
                "Arthur Conan Doyle",
                "Leo Tolstoy",
                "Edgar Allan Poe",
                "Robert Ervin Howard",
                "Rabindranath Tagore",
                "Rudyard Kipling",
                "Seneca",
                "John Donne",
                "Sarah Williams",
                "Oscar Wilde",
                "Catullus",
                "Alfred Tennyson",
                "William Blake",
                "Charles Dickens",
                "John Keats",
                "Theodor Herzl"
        ).stream();
    }

    private static Stream<String> createSecondStream() {
        return Arrays.asList(
                "Percy Bysshe Shelley",
                "Ernest Hemingway",
                "Barack Obama",
                "Anton Chekhov",
                "Henry Wadsworth Longfellow",
                "Arthur Schopenhauer",
                "Jacob De Haas",
                "George Gordon Byron",
                "Jack London",
                "Robert Frost",
                "Abraham Lincoln",
                "O. Henry",
                "Ovid",
                "Robert Louis Stevenson",
                "John Masefield",
                "James Joyce",
                "Clark Ashton Smith",
                "Aristotle",
                "William Wordsworth",
                "Jane Austen"
        ).stream();
    }

    private static Stream<String> createThirdStream() {
        return Arrays.asList(
                "Niccolò Machiavelli",
                "Lewis Carroll",
                "Robert Burns",
                "Edgar Rice Burroughs",
                "Plato",
                "John Milton",
                "Ralph Waldo Emerson",
                "Margaret Thatcher",
                "Sylvie d'Avigdor",
                "Marcus Tullius Cicero",
                "Banjo Paterson",
                "Woodrow Wilson",
                "Walt Whitman",
                "Theodore Roosevelt",
                "Agatha Christie",
                "Ambrose Bierce",
                "Nikola Tesla",
                "Franz Kafka"
        ).stream();
    }
}