Lambda expressions in Java 8

Question

I want to generate a list of numbers using lambda expressions and not a for-loop.

So let's say I want to generate a list of all triangular numbers under 100. Triangular numbers are numbers which follow the formula: (n*n+n)/2

What is the best way of doing this? Currently I have this:

    Stream.iterate(1, n -> n + 1).limit(100)
            .map(n -> (n * n + n) / 2)
            .filter(a -> a < 100)
            .map(a -> a + "")
            .collect(Collectors.joining(", ", "Numbers: ", "."));

But this seems unnecessarily overkill with the amount of calculations. I iterate n over 1 to 100 (because lets assume I do not know what the max value for n is), then I map the triangle number function of that list and then I check which numbers are under 100. Is there a more efficient way in doing this? Also: can I generate the triangle numbers using only the iterate function of Stream instead of using iterate, limit and then map?

EDIT: So the main point here is: how can calculation of traingle numbers stop as soon as one of the triangle numbers exceeds 100? Usually I would write it like this:

ArrayList<Integer> triangles = new ArrayList<>(); 
for (int n=1;true;n++) {
    int num = (n*n+n)/2;

    if (num>100) break;

    triangles.add(num);
}

which stops as soon as a triangle number exceeds 100, which is very efficient; how can I retain this efficiency in lambda expression?

Answer 1

In general case what you're looking for is take-while. Unfortunately, it has no default implementation in Java 8 streams. See a question about take-while.

Answer 2

If all you're looking to do is convert the given sequence into the triangle (as you describe), this does it much simpler.

List<Integer> l = IntStream.rangeClosed(1, 100)
            .mapToObj(n -> (n*n + n) / 2)
            .collect(Collectors.toList());

the primitive stream wrappers need an extra step to up-convert to objects, hence the mapToObj method.

If you're looking to stop filtering when you hit 100, easiest way I can think of is

    IntFunction<Integer> calc =n -> (n*n+n) / 2; 
    List<Integer> l = IntStream.rangeClosed(1, 100)
            .filter(n -> calc.apply(n) < 100)
            .mapToObj(calc)
            .collect(Collectors.toList());

Based on the changes to your question, I think this is also pretty important to point out. If you want to mirror what you used to do, that would look like this:

    List<Integer> results = new ArrayList<>(100);
    IntStream.rangeClosed(1, 100).forEach(i -> {
        int tri =calc.apply(i);
        if(tri < 100) {
            results.add(tri);
        }
    });

It's worth pointing out that streams are not necessarily ordered (though the default implementation follows the iterator). If this were converted to a parallel stream you would see the difference (and power of streams). You can't break from the execution because then you're assuming a certain amount about the processing order. By filtering early (in my second form) you'll ensure that you only end up with a result stream of 13 entries in it before the final calculation. Take this parallel option as a note as well.

    List<Integer> l = IntStream.rangeClosed(1, 100).parallel()
            .filter(n -> calc.apply(n) < 100)
            .mapToObj(calc)
            .collect(Collectors.toList());

You'll see they're still ordered, but the computation of them was done on multiple threads.