Composing streams with flatmap in Java 8

Question

Let's consider I have the following class:

class A {
   int i, j, k;

   public A(int i, int j, int k) {
     this.i = i; this.j = j; this.k = k;
   }
}

where i, j, k have a known range: r_i, r_j, r_k. Now I want to to generate all possible instances of A in this range. I could come up with something like:

Stream.iterate(0, n -> ++n).limit(r_i)
.flatMap(i -> Stream.iterate(0, n -> ++n).limit(r_j)
.flatMap(j -> Stream.iterate(0, n -> ++n).limit(r_k)
.map(k -> new A(i, j, k)))).collect(Collectors.toList())

First, it's too verbose. Is there a way to shorten it? In particular I couldn't find a range on Stream. Second, the compiler cannot determine the type of the returned type. It considers it as List<Object> instead of the expected List<A>. How can I fix that?

@JonSkeet I tried and it has other problems. The flatMap there doesn't allow arbitrary return type, only integer. There is an awkward mapToObj method, but I haven't found flatmapToObj. — Wickoo, Jan 06 '15 at 15:50
Right. It pains me to see Java streams being awkward when LINQ in C# makes this sort of thing so simple :( — Jon Skeet, Jan 06 '15 at 15:56
This can definitely be done with `IntStream.range` and `mapToObj` at the end. Are you sure your compiler complains or is it just your IDE? I just copied your code in IntelliJ IDEA 14 and it does not show any warnings or errors or any sort. — Edwin Dalorzo, Jan 06 '15 at 16:23
@EdwinDalorzo Have you tried List = my code? It cannot infer that the result should be List . About `IntStream.range`, the problem is that there should be a `flatMapToObj` or something. Can you try with `mapToObj` only and show me the code? — Wickoo, Jan 06 '15 at 16:28
@Ali I definitely did and it worked like a charm. I am using Java 8 Build 20 and IntelliJ 14. — Edwin Dalorzo, Jan 06 '15 at 16:36
@EdwinDalorzo yes, you're right. It looks like IntelliJ can infer it, but Eclipse can't. How about `IntStream.range`, could you get that running? — Wickoo, Jan 06 '15 at 16:47
@Ali Yes, I could make it work too. It is not a matter of type inference. The Java compiler does pretty well, but many IDEs are full of bugs in this area. Intellij 14 when it was just released had a lot of problems in this area and with every new release they have been improving a lot. Developers have been working on their own IDE type inference algorithms, I suppose, trying to emulate, as best as they can, what the compiler does. But chances are that there are still bugs here and there. With time, this will get better, but you should ultimate trust your compiler, not the IDE. — Edwin Dalorzo, Jan 06 '15 at 16:52
@EdwinDalorzo can you please post your version with `range`? I'm curious. — Wickoo, Jan 06 '15 at 16:59

score 6 · Answer 1 · answered Jan 06 '15 at 16:54

One way of using range is to perform a boxing conversion right afterwards:

List<A> list=IntStream.range(0, r_i).boxed()
  .flatMap(i -> IntStream.range(0, r_j).boxed()
    .flatMap(j -> IntStream.range(0, r_k)
      .mapToObj(k -> new A(i, j, k)))).collect(Collectors.toList());

It’s not the most beautiful code but IntStream.range(0, max).boxed() is still better than Stream.iterate(0, n -> n+1).limit(max)…

One alternative is to use a real flattening operation rather than nested operations:

List<A> list=IntStream.range(0, r_i).boxed()
  .flatMap(i  -> IntStream.range(0, r_j).mapToObj(j -> new int[]{i,j}))
  .flatMap(ij -> IntStream.range(0, r_k).mapToObj(k -> new A(ij[0], ij[1], k)))
  .collect(Collectors.toList());

The main drawback I see is that it suffers from the absence of an IntPair or Tuple<int,int> type. So it uses an array as a work-around.

hanjoonk · Answer 2 · 2015-01-06T16:50:53.163

if it's ok to have mutable variable, you could get the List of class A like this....

List<A> newCollect = new ArrayList<>();
IntStream.range(0, r_i).forEach(
    i -> IntStream.range(0, r_j).forEach(
        j -> IntStream.range(0, r_k).forEach(
            k -> newCollect.add(new A(i, j, k))
        )
    )
);

or you can make List of List of List of A, then flatMap twice like this...

List<A> newCollect2 = IntStream.range(0, r_i).mapToObj(
    i -> IntStream.range(0, r_j).mapToObj(
        j -> IntStream.range(0, r_k).mapToObj(
            k -> new A(i, j, k)
        ).collect(Collectors.toList())
    ).collect(Collectors.toList())
)
.flatMap(a -> a.stream())
.flatMap(a -> a.stream())
.collect(Collectors.toList());

Composing streams with flatmap in Java 8

2 Answers2

Linked