Java Streams with state - a trivial exercise

Question

In the process to get my hands in Java 8 streams, the following exercise stopped me.

Given the IntStream.range(0, 6). Produce the String Stream below:

"0, 1"
"1, 2"
"2, 3"
"3, 4"
"4, 5"

I thought of using Collectors.collectAndThen to pass it to the good old list or array and loop to construct the list of strings as follows:

List<String> strgs = new ArrayList<>();
String prev = String.valueOf(nums[0]);
for (int i = 1; i < nums.length; i++) {
    strgs.add(prev+", "+String.valueOf(nums[i]));
    prev = String.valueOf(nums[i]);  
}

But it does not use the power of streams. I felt like Venkat Subramaniam says "I felt like taking a shower afterwards". I want to know how to apply the functional techniques so I can skip taking a shower after coding!

Also, I would like to avoid libraries like StreamEx or JavaRx, I want to stick to the plain Java 8 APIs.

Edit: @Tunaki, thank you for pointing the unclear wording in my question. It is a pair formed of two consecutive elements of the Stream. More concrete, a Stream like [1, 3, 5, 7, 9, ...] will be

"1, 3"
"3, 5"
"5, 7"
...

Edit 2

After saluting all the answers, Although my question is a duplicate to another question as pointed out by Tunaki. I want to extend a community discussion for the answer contributed by Bohemian. Although his answer was disliked by some, It raises a serious issue which is a reduce operation with side effects. My request to the community is to provide a reasonable counter valid technique to the issue. Thus I want to reuse Bohemian answer as follows:

Given the input: nums =new int[]{1,3,5,7,9}

Please consider the snippet below:

List<CharSequence> stringList = new ArrayList<>();
IntBinaryOperator reductionWithSideEffect = (int left, int right) -> {
        stringList.add(new StringBuilder().append(left).append(", ").append(right));
        return right;
};
Arrays.stream(nums)
        .reduce(reductionWithSideEffect);
System.out.println(String.join(", ", stringList));

Answer 1

To my opinion the most clean way to solve this problem is to write a custom spliterator and create a Stream over it. It's not very hard if you don't need absolutely maximum performance and don't care about parallel processing (parallel stream will work, but inefficiently). Something like this would work:

public static <T, R> Stream<R> pairMap(BaseStream<T, ?> source,
        BiFunction<? super T, ? super T, ? extends R> mapper) {
    Spliterator<T> spltr = source.spliterator();
    long sourceSize = spltr.estimateSize();
    Spliterator<R> result = new Spliterators.AbstractSpliterator<R>(
            sourceSize > 0 && sourceSize < Long.MAX_VALUE ? sourceSize - 1 : sourceSize,
            spltr.characteristics() & (Spliterator.ORDERED | Spliterator.SIZED)) {
        T prev;
        boolean started;

        @Override
        public boolean tryAdvance(Consumer<? super R> action) {
            if (!started) {
                if (!spltr.tryAdvance(t -> prev = t))
                    return false;
                started = true;
            }
            return spltr.tryAdvance(t -> action.accept(mapper.apply(prev, prev = t)));
        }
    };
    return StreamSupport.stream(result, source.isParallel()).onClose(source::close);
}

Here the mapper is the function which creates the element of the new stream based on the pair of adjacent elements of the input stream.

Usage example:

pairMap(IntStream.range(0, 6), (a, b) -> a + ", " + b).forEach(System.out::println);

Output:

0, 1
1, 2
2, 3
3, 4
4, 5

Answer 2

As Tunaki mentions in the comments, the Stream API isn't ideal for this use case. The best I could do was to write a stateful mapping function to remember what the last encountered element was.

Note - as Tagir Valeev points out in the comments, this solution breaks if the result stream is reverted to parallel mode by the caller using BaseStream.parallel().

public class StreamExercise {
    public static void main(String[] args) {
        f(IntStream.range(0, 6))
            .forEach(s -> System.out.println(s));

        System.out.println();

        f(IntStream.of(1,3,5,7,9))
            .forEach(s -> System.out.println(s));
    }

    private static Stream<String> f(IntStream input) {
        IntFunction<String> mapper = new IntFunction<String>() {
            private int last = -1;

            @Override
            public String apply(int value) {
                String result = last + ", " + value;
                last = value;
                return result;
            }

        };

        return input.sequential().mapToObj(mapper).skip(1);
    }
}

Output:

0, 1
1, 2
2, 3
3, 4
4, 5

1, 3
3, 5
5, 7
7, 9

Answer 3

Simple and Easy :

public static void main(String[] args) {
    generatePairs(Arrays.asList(1, 3, 5, 7, 9)).forEach(System.out::println);
}

public static <E> List<Pair<E>> generatePairs(List<E> src) {
    if (src.size() < 2) {
        throw new IllegalArgumentException("src.size must be greater than 1");
    }
    return IntStream.range(0, src.size() - 1)
            .mapToObj(i -> new Pair<>(src.get(i), src.get(i + 1)))
            .collect(Collectors.toList());
}

and the Pair class :

public final class Pair<E> {

    private E left;
    private E right;

    public Pair() {
    }

    public Pair(E left, E right) {
        this.left = left;
        this.right = right;
    }

    public E getLeft() {
        return left;
    }

    public void setLeft(E left) {
        this.left = left;
    }

    public E getRight() {
        return right;
    }

    public void setRight(E right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "{" + left +
                ", " + right +
                '}';
    }

}

EDIT :

Here is a complete example :

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public final class Pair<L, R> implements Comparable<Pair<L, R>> {

    private final Comparator<? super L> comparator;

    private L left;
    private R right;

    public Pair() {
        comparator = null;
    }

    public Pair(Comparator<? super L> comparator) {
        this.comparator = comparator;
    }

    public Pair(L left, R right) {
        this(left, right, null);
    }

    public Pair(L left, R right, Comparator<? super L> comparator) {
        this.left = left;
        this.right = right;
        this.comparator = comparator;
    }

    public L getLeft() {
        return left;
    }

    public void setLeft(L left) {
        this.left = left;
    }

    public R getRight() {
        return right;
    }

    public void setRight(R right) {
        this.right = right;
    }

    @Override
    public int hashCode() {
        return Objects.hash(left, right);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || !(obj instanceof Pair)) {
            return false;
        }
        Pair that = (Pair) obj;
        return Objects.equals(left, that.left) && Objects.equals(right, that.right);
    }

    @Override
    public String toString() {
        return "{" + left +
                ", " + right +
                '}';
    }

    @Override
    @SuppressWarnings("unchecked")
    public int compareTo(Pair<L, R> o) {
        return comparator == null ? ((Comparable<? super L>) left).compareTo(o.left) : comparator.compare(left, o.left);
    }

    public static abstract class Stream {

        private Stream() {
        }

        public final java.util.stream.Stream<Pair<Integer, Integer>> of(IntStream src) {
            return of(src.boxed());
        }

        public final java.util.stream.Stream<Pair<Long, Long>> of(LongStream src) {
            return of(src.boxed());
        }

        public final java.util.stream.Stream<Pair<Double, Double>> of(DoubleStream src) {
            return of(src.boxed());
        }

        public final <E> java.util.stream.Stream<Pair<E, E>> of(java.util.stream.Stream<E> src) {
            return of(src.collect(Collectors.toList()));
        }

        @SuppressWarnings("all")
        public abstract <E> java.util.stream.Stream<Pair<E, E>> of(E... src);

        public abstract <E> java.util.stream.Stream<Pair<E, E>> of(List<E> src);

        protected static void checkSize(int size) {
            if (size < 1) {
                throw new IllegalArgumentException("Empty source.");
            }
        }

        protected static <E> E getOrNull(E[] array, int index) {
            return index < array.length ? array[index] : null;
        }

        protected static <E> E getOrNull(List<E> list, int index) {
            return index < list.size() ? list.get(index) : null;
        }

        public static Stream chained() {
            return new ChainedPairStream();
        }

        public static Stream distinct() {
            return new DistinctPairStream();
        }

    }

    private static final class ChainedPairStream extends Stream {

        @SafeVarargs
        public final <E> java.util.stream.Stream<Pair<E, E>> of(E... src) {
            int length = src.length;
            checkSize(length);
            return IntStream.range(0, Math.max(1, length - 1)).mapToObj(i -> new Pair<>(src[i], getOrNull(src, i + 1)));
        }

        public final <E> java.util.stream.Stream<Pair<E, E>> of(List<E> src) {
            int size = src.size();
            checkSize(size);
            return IntStream.range(0, Math.max(1, size - 1)).mapToObj(i -> new Pair<>(src.get(i), getOrNull(src, i + 1)));
        }

    }

    private static final class DistinctPairStream extends Stream {

        @SafeVarargs
        public final <E> java.util.stream.Stream<Pair<E, E>> of(E... src) {
            int length = src.length;
            checkSize(length);
            return IntStream.iterate(0, i -> i + 2)
                    .limit((long) Math.ceil(length / 2.0))
                    .mapToObj(i -> new Pair<>(src[i], getOrNull(src, i + 1)));
        }

        public final <E> java.util.stream.Stream<Pair<E, E>> of(List<E> src) {
            int size = src.size();
            checkSize(size);
            return IntStream.iterate(0, i -> i + 2)
                    .limit((long) Math.ceil(size / 2.0))
                    .mapToObj(i -> new Pair<>(src.get(i), getOrNull(src, i + 1)));
        }

    }

    public static void main(String[] args) {
        Pair.Stream.distinct().of(1, 2, 3, 4, 5, 6).forEach(System.out::println);

        Pair.Stream.chained().of(Arrays.asList(1, 3, 5, 7, 9)).forEach(System.out::println);

        Pair.Stream.chained().of(Arrays.stream(new int[]{0, 2, 4, 6, 8})).forEach(System.out::println);
        Pair.Stream.distinct().of(Arrays.stream(new int[]{0, 2, 4, 6, 8})).forEach(System.out::println);

        Pair.Stream.distinct().of(IntStream.range(0, 6)).forEach(System.out::println);
    }

}

Answer 4

I think the shortest code to get the job done is:

IntStream.range(0, 6).reduce((a, b) -> {System.out.println(a + ", " + b); return b;});

---

Since the above (working) code is causing debate, this then is a simple, readable solution that uses the API acceptably:

class PairPrinter implements IntConsumer {
    private boolean set;
    private int previous;

    public void accept(int i) {
        if (set) {
            System.out.println(previous + ", " + i);
        }
        set = true;
        previous = i;
    }
}

PairPrinter printer = new PairPrinter();
IntStream.range(0, 6).forEach(printer);

Which (also) produces the desired result.