Collect certain elements from stream

Question

How can I extract two elements from a Stream by their positions? For example I'm trying to extract element 0 and 1 (these numbers are arbitrary!) from a Stream<String>. A naive approach is this:

List<String> strings = Arrays.asList("s0", "s1", "s2", "s3", "s4");
Consumer<String> c0 = s -> System.out.println("c0.accept(" + s + ")");
Consumer<String> c1 = s -> System.out.println("c1.accept(" + s + ")");
strings.stream().skip(0).peek(c0).skip(1).peek(c1).findAny();

This produces the following output:

c0.accept(s0)
c0.accept(s1)
c1.accept(s1)

I understand that it's because s0 will enter the stream, encounter skip(0), then peek(c0) (which gives the the first line) and then skip(1), which will skip this element and then apparently continue with the next element from the beginning of the stream.

I thought I could use these consumers to extract the strings, but c0 would be overwritten by the second element:

String[] extracted = new String[2];
c0 = s -> extracted[0];
c1 = s -> extracted[1];

EDIT:

These are the characteristics of the stream:

• There's a stream only, not a list or an array
• The stream is possibly infinite
• The stream can be made sequential

Answer 1

Given your restriction you can combine the limit() with custom collector like this:

public static <T, A, R> Collector<T, ?, R> collectByIndex(Set<Integer> wantedIndices, 
                                                          Collector<T, A, R> downstream) {
    class Acc {
        int pos;
        A acc = downstream.supplier().get();
    }
    return Collector.of(Acc::new, (acc, t) -> {
        if(wantedIndices.contains(acc.pos++))
            downstream.accumulator().accept(acc.acc, t);
    }, (a, b) -> {throw new UnsupportedOperationException();}, // combining not supported
       acc -> downstream.finisher().apply(acc.acc));
}

Here Set<Integer> wantedIndices is the set containing the indices of wanted elements (not limited by 2). Usage:

Set<Integer> wantedIndices = new HashSet<>(Arrays.asList(1, 3));
Stream<String> input = Stream.of("s0", "s1", "s2", "s3", "s4");
List<String> result = input.limit(Collections.max(wantedIndices)+1)
            .collect(collectByIndex(wantedIndices, Collectors.toList()));
// [s1, s3]

Answer 2

Here's an approach I haven't seen in the other answers. It uses a variation of the ubiquitous Pair class:

class Pair<T> {
    final T first;
    final T last;
    Pair(T t1, T t2) { first = t1; last = t2; }
    Pair(T t) { first = last = t; }
    Pair<T> merge(Pair<T> other) { return new Pair<>(this.first, other.last); }
}

Once you have this, you can easily get the first and last elements of a stream. Given an infinite stream and desired indexes, you can use skip() and limit() to trim the stream to contain just the desired elements:

static <T> Pair<T> firstAndLast(Stream<T> stream, int firstIndex, int lastIndex) {
    // ensure indexes >= 0 and firstIndex <= lastIndex
    return stream.skip(firstIndex)
                 .limit(lastIndex - firstIndex + 1)
                 .map(Pair::new)
                 .reduce(Pair::merge)
                 .orElseThrow(() -> new IllegalArgumentException("nonexistent"));
}

Other variations would include inlining the construction or merge logic into the stream operations instead of having it on the Pair class. Refactor to taste.

You'd use it like this:

    Stream<String> str = Stream.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j");
    Pair<String> pair = firstAndLast(str, 4, 5);
    System.out.println(pair.first + " " + pair.last);

    e f

Answer 3

This solution comes from the comment by Federico Peralta Schaffner:

public String[] collect(Stream<String> stream, int... positions) {
    String[] collect = new String[positions.length];
    Iterator<String> iterator = stream.iterator();
    int skipped = 0;
    for (int pos = 0; pos < positions.length; pos++) {
        while (skipped++ < positions[pos]) {
            iterator.next();
        }
        collect[pos] = iterator.next();
    }
    return collect;
}

This is the most direct and straightforward idea and works great.

Answer 4

The main obstacle is the single-use nature of Streams which can be circumvented:

static <T> List<T> get(Stream<? extends T> s, int... positions) {
    Spliterator<? extends T> sp=s.spliterator();
    ArrayList<T> list=new ArrayList<>(positions.length);
    int current=0;
    for(int i: positions) {
        if(i<current) throw new IllegalArgumentException("positions not ascending");
        Optional<? extends T> o
            =StreamSupport.stream(sp, false).skip(i-current).findFirst();
        if(!o.isPresent()) break;
        current=i+1;
        list.add(o.get());
    }
    return list;
}

Though I’m not sure whether I like it…

Answer 5

You could write something like the following:

public static void main(String[] args) throws Exception {
    List<String> strings = Arrays.asList("s0", "s1", "s2", "s3", "s4");
    System.out.println(getNthElement(strings.stream(), 0)); // prints "s0"
    System.out.println(getNthElement(strings.stream(), 1)); // prints "s1"
}

private static <T> T getNthElement(Stream<T> stream, int n) {
    return stream.skip(n).findFirst().get();
}

Note that this will throw an exception if there are less than n elements in the stream. Also, it makes sense only if the Stream is not parallel.

Answer 6

This is a (not very beautiful, but easy and working) solution:

List<String> strings = Arrays.asList("s0", "s1", "s2", "s3", "s4");
String[] extracted = new String[2];
Consumer<String> c0 = s -> extracted[0] = extracted[0] == null ? s : extracted[0];
Consumer<String> c1 = s -> extracted[1] = extracted[1] == null ? s : extracted[1];
strings.stream().skip(0).peek(c0).skip(1 - 0).peek(c1).findAny();