How do I loop through streams using forEach() method?

In Java, you can loop through a Stream by using the forEach() method provided by the Stream API.

In the following example, we created a Stream of Strings. Each String represents a different programming language. The forEach() method accepts a Consumer, which is a functional interface representing an operation that accepts a single input argument and returns no result. In this case, we passed System.out::println that acts as a Consumer to print each element in the Stream.

Here is the basic code snippet:

package org.kodejava.util;

import java.util.stream.Stream;

public class ForEachExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Java", "Kotlin", "Scala", "Clojure");

        stream.forEach(System.out::println);
    }
}

Remember, a Stream should be operated on (invoking an action method like forEach() or collect()) only once. After that, it is consumed and cannot be used again. If you need to traverse it again, you will have to re-create.

Also, forEach() operation is a terminal operation i.e.; after applying this operation, we cannot apply any other Stream operation (neither transformation nor action) on Stream elements.

The following snippets are a few more examples using different types of data.

  • Stream of Integers
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        stream.forEach(System.out::println);
    }
}
  • Stream from a List
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "Kotlin", "Scala", "Clojure");
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);
    }
}
  • Stream from Array
import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        String[] array = new String[] {"Java", "Kotlin", "Scala", "Clojure"};
        Stream<String> stream = Arrays.stream(array);
        stream.forEach(System.out::println);
    }
}

In these examples, I just print the elements. You can replace System.out::println with your logic. Also, you can handle exceptions inside forEach() just like a regular loop.

How do I use for-each to iterate generic collections?

In this example you will learn you to iterate a generic collection using the for-each loop. There was actually no for-each keyword or statement in Java. It just a special syntax of the for loop. The structure or syntax of the for-each loop is as follows.

for (type var : collections) {
    body;
}

This form of for loop is always read as foreach and the colon (:) character is read as “in”. Given that definition, if the type is a String you will read the syntax above as “foreach String var in collections”. The var in the statement above will be given each value from the collections during the iteration process.

Let’s compare two codes, the first one that use a generic and another code that does not use a generic so we can see the difference from the iteration perspective when working with a collection.

package org.kodejava.generics;

import org.kodejava.generics.support.Customer;

import java.util.ArrayList;
import java.util.List;

public class ForEachGeneric {

    public void loopWithoutGeneric() {
        List customers = new ArrayList();
        customers.add(new Customer());
        customers.add(new Customer());
        customers.add(new Customer());

        for (int i = 0; i < customers.size(); i++) {
            Customer customer = (Customer) customers.get(i);
            System.out.println(customer.getFirstName());
        }
    }

    public void loopWithGeneric() {
        List<Customer> customers = new ArrayList<>();
        customers.add(new Customer());
        customers.add(new Customer());
        customers.add(new Customer());

        for (Customer customer : customers) {
            System.out.println(customer.getFirstName());
        }
    }
}

What you see from the code snippet above is how much more clean our code is when we are using the generic version of the collection. In the first method, the loopWithoutGeneric we have to manually cast the object back to the Customer type. But in the second method, the loopWithGeneric method, no cast is needed as the collection will return the same type as what the collection was declared to hold.

How do use <c:forEach> JSTL tag?

The <c:forEach> tag in the core JSTL tag library is a useful tag when we want to iterate over a collection of data such as array. It is commonly used to render a tabular data in our web pages in form of HTML table.

In the example below we display a weather data that we stored as two-dimensional array of string. After declaring and initializing the data with some value we put it into the request scope. Later on the <c:forEach> tag can use the data, iterates it row by row to form an HTML table. Our weather data consist of the date, condition and the high and low temperature.

<%@ page contentType="text/html;charset=UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Weather Forecast</title>

    <style>
        table, th, td {
            border: 1px solid #000;
            border-collapse: collapse;
        }
    </style>
</head>
<body>
<%
    String[][] data = {
            {"Oct 11", "Sunny", "30", "26"},
            {"Oct 12", "Sunny", "32", "28"},
            {"Oct 13", "Sunny", "31", "27"},
            {"Oct 14", "Partly Cloudy", "29", "25"},
            {"Oct 15", "Isolated T-Storms", "27", "25"}
    };
    request.setAttribute("weathers", data);
%>
<strong>5-Days Weather for Denpasar, Indonesia</strong>

<table>
    <tr>
        <th>DATE</th>
        <th>CONDITION</th>
        <th>TEMP. HIGH</th>
        <th>TEMP. LOW</th>
    </tr>
    <c:forEach var="weather" items="${weathers}">
        <tr>
            <td>${weather[0]}</td>
            <td>${weather[1]}</td>
            <td style="text-align: center">${weather[2]}℃</td>
            <td style="text-align: center">${weather[3]}℃</td>
        </tr>
    </c:forEach>
</table>
</body>
</html>

Our JSP page above creates the following output:

5-Days Weather for Denpasar, Indonesia

DATE CONDITION TEMP. HIGH TEMP. LOW
Oct 11 Sunny 30℃ 26℃
Oct 12 Sunny 32℃ 28℃
Oct 13 Sunny 31℃ 27℃
Oct 14 Partly Cloudy 29℃ 25℃
Oct 15 Isolated T-Storms 27℃ 25℃

Maven Dependencies

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

Maven Central