Is there any way to flatten these nested IntStreams into one? Is there shorter way?

I changed 4 nested for loops to nested IntStream but this solution doesn't look good. I don't know how to make it shorter? Should I use flatmap in some way?

IntStream.range(0, totalCluster).forEach(numCluster ->{
  writeToFile("Cluster__________________________" + numCluster);
  IntStream.range(0, totalAgency).forEach(numAgency ->{
    writeToFile("\n\tCluster_" + numCluster + "_Agency_" + numAgency);
    IntStream.range(0, totalProgramArea).forEach(numProgramArea ->IntStream.range(0, totalUsers).forEach(numUser ->{
      writeToFile("\n\t\t\tAgency_" + numAgency + "_" + "ProgramArea_" + numProgramArea + "_User_" + numUser);
    }));
  });
});

You are probably asking about a construct in form

IntStream.range(0, 2)
  .flatMap(i -> IntStream.range(0, 2))
  .flatMap(i -> IntStream.range(0, 2))
  .forEach(i -> /*... inner loop logic here ..*/ );

However, if you need the index of each iteration of every outer loop inside the innermost logic, there is no nice way of doing it. The answer to your question is - old fashioned for loops work better here.

Still, here is one example (I reduced clutter to improve readability):

IntStream.range(0, totalClusters).boxed()
  .flatMap(i -> IntStream.range(0, totalAgencies).mapToObj(j -> new int[]{i,j})). 
  .flatMap(k -> IntStream.range(0, totalAreas).mapToObj(j -> new int[]{k[0],k[1],j}))
  .forEach(o -> System.out.println(Arrays.toString(o)));

It prints

[0, 0, 0]
[0, 0, 1]
...
[1, 1, 1]

The problem with this code is that you have to allocate int arrays on heap instead of using loop counters from stack. I only used int[] for simplicity, it is not a good practice, in reality it is better to use some context object.

You can derive an idea of a solution from here.

Now, people often ask if there is a proper functional way of dealing with nested for loops. In a language like Haskell, you would use something like this, because lists are monads (or list comprehensions):

do
  i <- [0..2]
  j <- [0..3]
  return $ i*100 + j

You can definitely go for similar do-notation logic in Java, by creating your own library of function combinators. Even though it is possible, unlike in Scala, syntax of Java prevents the end result from looking better than old fashioned for loops, in this particular case.