Как чередовать (объединять) два потока Java 8?

Question

 Stream<String> a = Stream.of("one", "three", "five");
 Stream<String> b = Stream.of("two", "four", "six");

Что мне нужно сделать, чтобы вывод был ниже?

// one
// two
// three
// four
// five
// six

Я посмотрел на concat, но, как объясняет Javadoc, он просто добавляется один за другим, он не перемежается и не перемежается.

Stream<String> out = Stream.concat(a, b);
out.forEach(System.out::println);

Создает ленивый каскадный поток, элементами которого являются все элементы первого потока, за которым следуют все элементы второй поток.

Неправильно дает

 // one
 // three
 // five
 // two
 // four
 // six

Мог бы сделать это, если бы я собрал их и повторил, но надеялся на что-то более Java8-й, Streamy: -)

Примечание

Я не хочу архивировать потоки

Операция «zip» будет брать элемент из каждой коллекции и объединять их.

результат операции zip будет примерно таким: (нежелательным)

 // onetwo
 // threefour
 // fivesix

Answer 1

Одно решение с Iterator

final Iterator<String> iterA = a.iterator();
final Iterator<String> iterB = b.iterator();

final Iterator<String> iter = new Iterator<String>() {
  private final AtomicInteger idx = new AtomicInteger();
  @Override
  public boolean hasNext() { 
    return iterA.hasNext() || iterB.hasNext();
  }
  @Override
  public String next() {
    return idx.getAndIncrement() % 2 == 0 && iterA.hasNext() ? iterA.next() : iterB.next();
  }
};

 // Create target Stream with StreamEx from: https://github.com/amaembo/streamex    
 StreamEx.of(iter).forEach(System.out::println);

 // Or Streams from Google Guava
 Streams.stream(iter).forEach(System.out::println);

Или просто с помощью решения в abacus-util , предоставленного мной:

 AtomicInteger idx = new AtomicInteger();
 StreamEx.merge(a, b, (s1, s2) -> idx.getAndIncrement() % 2 == 0 ? Nth.FIRST : Nth.SECOND).forEach(Fn.println()); 

Answer 2

Как видно из комментариев к вопросу, я попробовал использовать zip:

Stream<String> a = Stream.of("one", "three", "five");
Stream<String> b = Stream.of("two", "four", "six");

Stream<String> out = interleave(a, b);


    public static <T> Stream<T> interleave(Stream<T> streamA, Stream<T> streamB) {
        return zip(streamA, streamB, (o1, o2) -> Stream.of(o1, o2)).flatMap(s -> s);
    }

    /**
    * https://stackoverflow.com/questions/17640754/zipping-streams-using-jdk8-with-lambda-java-util-stream-streams-zip
    **/
    private static <A, B, C> Stream<C> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<A, B, C> zipper) {
        final Iterator<A> iteratorA = streamA.iterator();
        final Iterator<B> iteratorB = streamB.iterator();
        final Iterator<C> iteratorC = new Iterator<C>() {
            @Override
            public boolean hasNext() {
                return iteratorA.hasNext() && iteratorB.hasNext();
            }

            @Override
            public C next() {
                return zipper.apply(iteratorA.next(), iteratorB.next());
            }
        };
        final boolean parallel = streamA.isParallel() || streamB.isParallel();
        return iteratorToFiniteStream(iteratorC, parallel);
    }

    private static <T> Stream<T> iteratorToFiniteStream(Iterator<T> iterator, boolean parallel) {
        final Iterable<T> iterable = () -> iterator;
        return StreamSupport.stream(iterable.spliterator(), parallel);
    }

Answer 3

Это может не быть хорошим ответом, потому что
(1) он собирает на карту, что вы не хотите делать, я думаю, и
(2) это не полностью без сохранения состоянияпоскольку он использует AtomicIntegers.

Все еще добавляя его, потому что
(1) он читабелен, и
(2) сообщество может получить представление об этом и попытаться улучшить его.

Stream<String> a = Stream.of("one", "three", "five");
Stream<String> b = Stream.of("two", "four", "six");

AtomicInteger i = new AtomicInteger(0);
AtomicInteger j = new AtomicInteger(1);

Stream.of(a.collect(Collectors.toMap(o -> i.addAndGet(2), Function.identity())),
        b.collect(Collectors.toMap(o -> j.addAndGet(2), Function.identity())))
        .flatMap(m -> m.entrySet().stream())
        .sorted(Comparator.comparing(Map.Entry::getKey))
        .forEach(e -> System.out.println(e.getValue())); // or collect

Вывод

one
two
three
four
five
six

@ Хольгера править

Stream.concat(a.map(o -> new AbstractMap.SimpleEntry<>(i.addAndGet(2), o)),
        b.map(o -> new AbstractMap.SimpleEntry<>(j.addAndGet(2), o)))
        .sorted(Map.Entry.comparingByKey())
        .forEach(e -> System.out.println(e.getValue())); // or collect

Answer 4

Гораздо более тупое решение, чем у Хольгера, но, возможно, оно будет соответствовать вашим требованиям:

private static <T> Stream<T> interleave(Stream<T> left, Stream<T> right) {
    Spliterator<T> splLeft = left.spliterator();
    Spliterator<T> splRight = right.spliterator();

    T[] single = (T[]) new Object[1];

    Stream.Builder<T> builder = Stream.builder();

    while (splRight.tryAdvance(x -> single[0] = x) && splLeft.tryAdvance(builder)) {
        builder.add(single[0]);
    }

    return builder.build();
}

Answer 5

Я бы использовал что-то вроде этого:

public static <T> Stream<T> interleave(Stream<T> a, Stream<T> b) {
    Spliterator<T> spA = a.spliterator(), spB = b.spliterator();
    long s = spA.estimateSize() + spB.estimateSize();
    if(s < 0) s = Long.MAX_VALUE;
    int ch = spA.characteristics() & spB.characteristics()
           & (Spliterator.NONNULL|Spliterator.SIZED);
    ch |= Spliterator.ORDERED;

    return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(s, ch) {
        Spliterator<T> sp1 = spA, sp2 = spB;

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            Spliterator<T> sp = sp1;
            if(sp.tryAdvance(action)) {
                sp1 = sp2;
                sp2 = sp;
                return true;
            }
            return sp2.tryAdvance(action);
        }
    }, false);
}

Он максимально сохраняет характеристики входных потоков, что позволяет проводить определенные оптимизации (например, для count() и toArray()).Кроме того, он добавляет ORDERED, даже если входные потоки могут быть неупорядоченными, чтобы отразить перемежение.

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