How To Use For-Each Loop In Java

Both methods give us the same result, but the For-Each Loop is a clear winner. The logic is much cleaner and easy to understand, making its functionalities more accessible to new programmers. 

However, even if For-Each loops look cleaner, there are some things they can’t do. Let’s talk about this in-depth.

Disadvantages of For-Each Loops

The first problem with For-Each loops is that they cannot modify the original array. This isn’t a problem when working with dynamic programs that must save the initial state. But there might be situations when a classic For Loop would be a better choice. Let’s see this in code:

for (int : marks)
{
     num = num*2;
}

// the original array stays the same

Unluckily, For-Each loops can’t keep track of the index within an array. Therefore, we can’t use any logic that implies obtaining the index of an element.

for (int num : numbers)
{
     if (num == target)
     {
          return ???;   // index can't be found
     }
}

For-Each loops cannot iterate backward through an array. Also, nesting loops and booleans are other areas where a For-Each Loop might not be a good idea.

Why Use For-Each Loops?

As its name suggests, this loop checks out every item of a collection or array. This allows us to process large databases with ease and efficiency.

The iteration of data is an everyday task for programmers, so any tool we can add to our skillset that will help with it should be welcomed with open arms.

With For-Each loops, the advantages of a cleaner and easy-to-understand code are worth the lack of some features, such as array modification. You can always use the classic For Loop if you need this particular functionality. So don’t worry if you can’t always apply the easier-to-write code, but keep it in mind for situations when it could save you hours of work!

Let’s explore other functionalities of the For-Each loop. This will give you a hint of what it can do in combination with other tools.

Let’s say we have a collection of arrays with data in them. Our goal will be to flatten this data into a single array with the For-Each loop. Check this out:

// stream of arrays

Input: arr[][] = {{1,2,3},{4,5,6},{7,8,9}}
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

As you can see in the code, we have a stream of arrays ready for processing. Each array contains a series of numbers. The code we’ll write will include some other Java methods, so take this as an opportunity to test your understanding of this coding language!

Let’s see how each code segment works.

class exmpl
{

    // Main function
    public static  Stream flattenStream(T[][] arrays) 
    {
         List list = new ArrayList<>();

         for (T[] array : arrays)
         {
             Arrays.stream(array)
             .forEach(list::add);
          }
          return list.stream();
    }

    public static void main(String[] args)
    {
          Integer [][] arr={
              {1,2,3},
              {4,5,6},
              {7,8,9}
          };
          Integer[] flatArray = flattenStream(arr)
                    .toArray(Integer[] ::new);
          System.out.println(Arrays.toString(flatArray));
    }
}

First, we established a function that contains everything else and declared a list to collect the items.

The next step is using the For-Each loop combined with the stream() method. Given the list of numbers, each item is now a stream of the list. The final return, outside of the For-Each loop, is the list converted into a single stream of information. 

When the stream is ready, it’s time to flatten the array. We declare each number, and then we call the function we previously coded onto each one. This function takes the data and returns everything in a single array.

This is just a minuscule example of how these fundamental tools allow you to handle data as a programmer. With them, you can play with information and find new ways to make your code more efficient and easier to debug.

Conclusion: How To Use For-Each Loop In Java

For-Each loops are the easiest way to iterate through an array or collection. The items collected in the chosen array get processed with any functionality we desire. Also, this processing can be done using a combination of multiple methods and functions.

Remember, these loops lack some features. Chiefly, they don’t support backward iteration, loop nesting, and index tracking. Always use a classic For Loop to avoid bugs if you need any of those functionalities. 

Nevertheless, the possibilities for development are limitless when you combine the For-Each Loop with other methods, such as stream(). This is what we want to leave you with. Always look for new ways to expand your horizon as a programmer, and never settle for a single toolset. 

We recommend taking a look at Java’s official documentation for further information.