Добавление двух потоков Java 8 или дополнительного элемента в поток

Я могу добавить потоки или дополнительные элементы, например:

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

И я могу добавлять новые вещи, как я, как это:

Stream stream = Stream.concat(
                       Stream.concat(
                              stream1.filter(x -> x!=0), stream2)
                              .filter(x -> x!=1),
                                  Stream.of(element))
                                  .filter(x -> x!=2);

Но это безобразно, потому что concatстатично. Если бы concatэто был метод экземпляра, вышеприведенные примеры было бы намного легче читать:

 Stream stream = stream1.concat(stream2).concat(element);

И

 Stream stream = stream1
                 .filter(x -> x!=0)
                 .concat(stream2)
                 .filter(x -> x!=1)
                 .concat(element)
                 .filter(x -> x!=2);

Мой вопрос:

1) Есть ли веская причина, почему concatстатический? Или я пропускаю какой-то эквивалентный метод экземпляра?

2) В любом случае, есть ли лучший способ сделать это?

Если вы добавите статический импорт для Stream.concat и Stream.of , первый пример может быть записан следующим образом:

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

Импорт статических методов с родовыми именами может привести к тому, что код станет трудным для чтения и обслуживания ( загрязнение пространства имен ). Поэтому может быть лучше создать свои собственные статические методы с более значимыми именами. Однако для демонстрации я буду придерживаться этого имени.

public static <T> Stream<T> concat(Stream<? extends T> lhs, Stream<? extends T> rhs) {
    return Stream.concat(lhs, rhs);
}
public static <T> Stream<T> concat(Stream<? extends T> lhs, T rhs) {
    return Stream.concat(lhs, Stream.of(rhs));
}

С помощью этих двух статических методов (возможно, в сочетании со статическим импортом) эти два примера можно записать следующим образом:

Stream<Foo> stream = concat(stream1, concat(stream2, element));

Stream<Foo> stream = concat(
                         concat(stream1.filter(x -> x!=0), stream2).filter(x -> x!=1),
                         element)
                     .filter(x -> x!=2);

Код теперь значительно короче. Тем не менее, я согласен, что читаемость не улучшилась. Так что у меня есть другое решение.

Во многих ситуациях коллекторы могут использоваться для расширения функциональности потоков. С двумя коллекторами внизу два примера можно записать следующим образом:

Stream<Foo> stream = stream1.collect(concat(stream2)).collect(concat(element));

Stream<Foo> stream = stream1
                     .filter(x -> x!=0)
                     .collect(concat(stream2))
                     .filter(x -> x!=1)
                     .collect(concat(element))
                     .filter(x -> x!=2);

Единственная разница между вашим желаемым синтаксисом и приведенным выше синтаксисом заключается в том, что вы должны заменить concat (...) на collect (concat (...)) . Два статических метода могут быть реализованы следующим образом (необязательно используется в сочетании со статическим импортом):

private static <T,A,R,S> Collector<T,?,S> combine(Collector<T,A,R> collector, Function<? super R, ? extends S> function) {
    return Collector.of(
        collector.supplier(),
        collector.accumulator(),
        collector.combiner(),
        collector.finisher().andThen(function));
}
public static <T> Collector<T,?,Stream<T>> concat(Stream<? extends T> other) {
    return combine(Collectors.toList(),
        list -> Stream.concat(list.stream(), other));
}
public static <T> Collector<T,?,Stream<T>> concat(T element) {
    return concat(Stream.of(element));
}

Конечно, у этого решения есть недостаток, о котором следует упомянуть. collect - это последняя операция, которая потребляет все элементы потока. Кроме того, concat сборщика создает промежуточный ArrayList каждый раз, когда он используется в цепочке. Обе операции могут оказать существенное влияние на поведение вашей программы. Однако, если удобочитаемость важнее производительности , это может быть очень полезным подходом.

К сожалению, этот ответ, вероятно, мало или вообще не поможет, но я провел судебный анализ списка рассылки Java Lambda, чтобы посмотреть, смогу ли я найти причину этого дизайна. Это то, что я узнал.

В начале был экземпляр метода для Stream.concat (Stream)

В списке рассылки я ясно вижу, что метод изначально был реализован как метод экземпляра, как вы можете прочитать в этой теме Пола Сандоса об операции concat.

В нем они обсуждают проблемы, которые могут возникнуть в тех случаях, когда поток может быть бесконечным, и что будет означать конкатенация в этих случаях, но я не думаю, что это было причиной для модификации.

В этом другом потоке вы видите, что некоторые ранние пользователи JDK 8 спрашивали о поведении метода экземпляра concat при использовании с нулевыми аргументами.

Этот другой поток показывает, однако, что проект метода concat обсуждался.

Преобразуется в Streams.concat (Stream, Stream)

Но без какого-либо объяснения, внезапно, методы были изменены на статические методы, как вы можете видеть в этой теме об объединении потоков . Это, пожалуй, единственная почтовая рассылка, которая проливает немного света на это изменение, но мне было недостаточно ясно определить причину рефакторинга. Но мы можем видеть, что они сделали коммит, в котором они предложили переместить concatметод из Streamкласса помощника в класс помощника.Streams .

Преобразуется в Stream.concat (Stream, Stream)

Позже, он был снова перемещен из Streamsв Stream, но опять же, без объяснения этого.

Итак, суть в том, что причина дизайна мне не совсем понятна, и я не смог найти хорошего объяснения. Я думаю, вы все еще можете задать вопрос в списке рассылки.

Некоторые альтернативы для объединения потоков

Этот другой поток Майкла Хиксона обсуждает / спрашивает о других способах объединения / объединения потоков

1. Чтобы объединить два потока, я должен сделать это:

   Stream.concat(s1, s2)

   не этот:

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

   ... право?

2. Чтобы объединить более двух потоков, я должен сделать это:

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

   не этот:

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

   ... право?

Моя библиотека StreamEx расширяет функциональность Stream API. В частности, он предлагает методы, такие как append и prepend, которые решают эту проблему (внутренне они используют concat). Эти методы могут принимать либо другой поток, либо коллекцию, либо массив varargs. Используя мою библиотеку, ваша проблема может быть решена следующим образом (обратите внимание, что x != 0для непримитивного потока это выглядит странно):

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));

Кстати, есть также ярлык для вашей filterоперации:

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

Просто сделать:

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

где identity() статический импорт Function.identity().

Объединение нескольких потоков в один поток аналогично выравниванию потока.

Однако, к сожалению, по какой-то причине flatten()метод не включен Stream, поэтому вы должны использовать flatMap()функцию идентификации.

Вы можете использовать метод Guava , который будет очень коротким при статическом импорте:Streams.concat(Stream<? extends T>... streams)

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

Если вы не возражаете против использования сторонних библиотек, у cyclops-реагирует расширенный тип потока, который позволит вам сделать это с помощью операторов добавления / добавления.

Отдельные значения, массивы, итерации, потоки или реактивные потоки Издатели могут добавляться и добавляться в качестве методов экземпляра.

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);

[Раскрытие Я ведущий разработчик циклоп-реакции]

В конце концов я не заинтересован в объединении потоков, а в получении объединенного результата обработки каждого элемента всех этих потоков.

Хотя объединение потоков может оказаться громоздким (таким образом, этот поток), объединение их результатов обработки довольно легко.

Ключом к решению является создание собственного сборщика и обеспечение того, чтобы функция поставщика для нового сборщика каждый раз возвращала одну и ту же коллекцию (а не новую ). Этот код иллюстрирует приведенный ниже код.

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();
    }
}

Как насчет написания собственного метода 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;
}

По крайней мере, это делает ваш первый пример намного более читабельным.