S

#### Sebastian

I'd like to start an open discussion on issues involving the Streams

API. As an exercise, I have looked at generating the first n primes,

for some given n, using the sieve of Eratosthenes. It seemed a

plausible enough proposition, seeing that the sieve involves repeatedly

filtering a sequence of integers.

However, things were made difficult by the fact that Stream#findFirst()

is a terminal (and short-circuiting) operation, so I couldn't use it

to access the first stream element to incrementally build a result.

The solution shown below uses an additional storage for these elements,

and finds out which of the elements passing through the stream are new

primes by counting them at each stage. This works, but it is certainly

not something to show your functional programming friends.

I'd be grateful for suggestions for improvement, or other solutions.

I'd also like to know how this could be enhanced to generate an

infinite stream of primes (i. e. when the upper bound n is unknown and

new filters may need to be generated on the fly). I could imagine a

solution if it were possible to "pipe" one stream into another, but that

doesn't seem to be possible.

Perhaps the lesson is that some things are best not done using

streams. I also include a Java7 while-loop version of the same below.

This is more concise, clearer and easily generalizes to an infinite

stream. (However, it is eager, not lazy, and would take some more effort

to convert to a lazy solution, probably involving Callbacks and perhaps

losing its conciseness.)

What are your opinions?

Best,

Sebastian

Code follows. This has been tested to compile and run with lambda b88.

======================================================================

public void primes(int n) {

List<Integer> primes = new ArrayList<>();

Stream<Integer> s = Stream.iterate(2, x -> x + 1);

for (int i = 0; i < n; i++) {

int k = i;

Consumer<Integer> kthPrime = kthPrime(k, primes);

s = s.peek(kthPrime).filter(x -> {int p = currPrime(k,primes);

return x == p || x % p != 0;});

}

assert primes.isEmpty();

s.limit(n).forEach(x -> System.out.print(x + " "));

assert primes.size() == n;

}

/**

* Find the prime that is used in the kth filter. That is the kth prime

* if it has been discovered yet, otherwise it is a smaller prime that

* is currently passing throgh the stream and must be let through the

* filter.

* @param k the filter number

* @param primes the list of primes

* @return the largest prime with an index less than or equal to k

*/

private Integer currPrime(int k, List<Integer> primes) {

return primes.get(min(k,primes.size()-1));

}

/**

* Mark the kth prime number for reference in a subsequent filter.

* @param k the prime number index

* @param primes the list of primes

* @return a consumer that puts the kth integer that comes its way

* into the specified list of primes

*/

private Consumer<Integer> kthPrime(int k, List<Integer> primes) {

return new Consumer<Integer>() {

private int idx;

@Override

public void accept(Integer p) {

if (idx > k) return;

if (idx == k) primes.add(p);

idx++;

}

};

}

/**

* For comparison, here is a Java 7 version of the prime generator.

* @param n limit on the number of primes

*/

public void primesJava7(int n) {

List<Integer> primes = new ArrayList<>();

int x = 2;

while (primes.size() < n) {

boolean isPrime = true;

for (Iterator<Integer> it = primes.iterator();

isPrime && it.hasNext() {

if (x % it.next() == 0) isPrime = false;

}

if (isPrime) primes.add(x);

x++;

}

System.out.println(primes);

}