wanted to limit the looping while using ForEach

Say I got 100 records from DB, I want to loop 10 times and perform some action.
and loop again and perform some action.. it continues until the last record is read.

The problem what i am seeing is

for (int number: numbers) {
    add(number);
    //after adding 10 items I want to complete a function and continue the loop
}

But here in Java, if use the above loop we can see it will iterate the complete list and comes out.

I know in older versions, we can iterate by counter like

for(int i=0; i<10;i++)  

some thing like this.

My question is if forEach loop doesnot provide this flexibility, then why Sun Java introduced to a looping mechanism where it will iterate completely.

Trying to understand the logic of this design.

You can use a forEach or for-in with a nested conditional.

for(number: numbers){
     if(number != (multOfTen)){
        
         myFunction(number);
         add(number);
    
     }else{

          add(number);

     }
}

you will need to replace multOfTen w/ an expression that includes only multiples of ten.
One way to do this is to use regEx to check that the last digit is zero (so long as your using integers.)

As the name suggests, forEach will iterate over the whole collection. This is the same for JavaScript and several other languages. However you can abort / skip the iteration with a condition (which depends on the language implementation details).

There are difference between for and forEach loop. There are reason why java has these 2. forEach is enhance for loop. Both have their usage based on requirements.

for

This we can use for general purpose. This is totally based on indexes. If you want to play with data at particular index or want to perform some actions based on index of element, you should use for.

forEach

this is used with only collections and arrays. This iterate over whole collections at once. Means you can't have index of element while iterating it. This is used when you manipulate each data in list regardless whats its index. For example to print all element in a given list, instead of writing classical for loop

for (int i =0; i < list.length(); i++){

  System.out.println(list(i));

}

we use forEach loop

list.forEach(e -> {
      System.out.println(e);
});

this is more readable, easy to use and crisp.

because sometimes the question or the implementation you're doing using java doesn't need the index of the array "simply".

so instead of writing the whole for(int i=0;i<arr.length;i++) thing you can just use foreach and instead of arr[i] you use a simple variable name.

This is actually possible using the same Stream api but it's beyond the scope of forEach. What you want to do isn't possible by limiting yourself to forEach. The purpose of forEach is to execute some action without bias on all elements of an Iterable or Stream. What you can do is break down your objects into groups of 10 and then for each grouping of 10, do what you want which is add all to the underlying collection and then perform some other action which is what you want as well.

        List<Integer> values = IntStream.range(0, 100)
                .boxed()
                .collect(Collectors.toList());

        int batch = 10; 

        List<List<Integer>> groupsOfTen = IntStream.range(0, values.size() / batch + 1)
                .map(index -> index * batch)
                .mapToObj(index -> values.subList(index,
                        Math.min(index + batch, values.size())))
                .collect(Collectors.toList());
        
        groupsOfTen.forEach(myListOfTen -> myListOfTen.forEach(individual -> {
            
        }));