Get the Index Values From forEach Loop in JSTL
Last updated: April 7, 2025
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
1. Overview
When working with JavaServer Pages (JSP), we often simplify our code using the JavaServer Pages Standard Tag Library (JSTL).
One of the most commonly used JSTL tags is <c:forEach>, which allows us to iterate over collections such as arrays, lists, or maps. While iterating, we frequently need to access the index of each element.
In this quick tutorial, we’ll explore getting the elements’ index values while iterating using the JSTL <c:forEach> tag.
2. Creating a Simple Example
As an example, we’ll create a simple Spring-MVC JSTL web application to list some predefined movies. For simplicity, we’ll skip Spring configurations such as Spring ViewResolver.
First, let’s look at the Movie POJO:
public class Movie {
private String title;
private int year;
public Movie(String title, int year) {
this.title = title;
this.year = year;
}
//... getter and setter methods are omitted
}Then, we need a Spring Controller class to process HTTP requests. So, let’s create one:
@Controller
public class JSTLForEachDemoController {
@RequestMapping(value = "/foreach-demo", method = RequestMethod.GET)
public ModelAndView forEachDemo(final Model model) {
ModelAndView mv = new ModelAndView("jstlForEachDemo");
List<Movie> movies = List.of(
new Movie("The Hurt Locker", 2008),
new Movie("A Beautiful Mind", 2001),
new Movie("The Silence of the Lambs", 1991),
new Movie("A Man for All Seasons", 1966),
new Movie("No Country for Old Men", 2007)
);
mv.addObject("movieList", movies);
return mv;
}
}As we can see, the JSTLForEachDemoController class has only one method to handle the “/foreach-demo” GET request. For simplicity, we prepared a List of hard-coded Movie objects and added it to the ModelAndView object named “movieList“. Further, we defined jstlForEachDemo as the view to present the Movie data.
Finally, let’s create a JSP file as the view at webapp/WEB-INF/views/jstlForEachDemo.jsp:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<style>
table, th, td {
border: 1px solid black;
border-collapse: collapse;
}
</style>
<head>
<title>JSTL ForEach Example</title>
</head>
<body>
<h1>Movie List</h1>
<div>
<table style="width: 50%">
<tr>
<th>Year</th>
<th>Title</th>
</tr>
<c:forEach var="movie" items="${movieList}">
<tr>
<td>${movie.year}</td>
<td>${movie.title}</td>
</tr>
</c:forEach>
</table>
</div>
</body>
</html>
As the code example shows, we used JSTL’s <c:forEach> tag to loop through the movieList object and generate the rows in the HTML table.
If we deploy our web application to a servlet container, such as Apache Tomcat, we can see the movies’ data by accessing the URL in a web browser:
Next, let’s figure out how to obtain each Movie element’s index during the forEach iteration.
3. Using varStatus to Access Index and Count
Fortunately, JSTL provides a built-in mechanism for getting the indexes of elements in a forEach loop. The varStatus attribute allows us to define a loop status variable that provides useful metadata about the iteration.
Next, let’s add the varStatus attribute to the <c:forEach> tag and show the element indexes in the HTML table:
...
<h1>Movie List</h1>
<div>
<table style="width: 50%">
<tr>
<th>varStatus.index</th>
<th>Year</th>
<th>Title</th>
</tr>
<c:forEach var="movie" items="${movieList}" varStatus="theLoop">
<tr>
<td>${theLoop.index}</td>
<td>${movie.year}</td>
<td>${movie.title}</td>
</tr>
</c:forEach>
</table>
</div>
...
In this example, we named varStatus in the forEach loop “theLoop” and obtained an element’s index by accessing varStatus‘s index property: theLoop.index.
Now, if we access the same URL, we can see the new column containing the indexes of the elements in movieList:
As the screenshot shows, varStatus‘s index is zero-based. However, sometimes, we want to have one-based indexes in our view. Of course, we can quickly achieve it by adding one to varStatus‘s index, for example, ${theLoop.index + 1}. In fact, varStatus offers the count property, which provides one-based indexes.
Next, let’s add another one-based index column next to the zero-based one, using varStatus.count:
...
<h1>Movie List</h1>
<div>
<table style="width: 50%">
<tr>
<th>varStatus.index</th>
<th>varStatus.count</th>
<th>Year</th>
<th>Title</th>
</tr>
<c:forEach var="movie" items="${movieList}" varStatus="theLoop">
<tr>
<td>${theLoop.index}</td>
<td>${theLoop.count}</td>
<td>${movie.year}</td>
<td>${movie.title}</td>
</tr>
</c:forEach>
</table>
</div>
...
Let’s redeploy our application and check the result in the browser:
The table includes one-based indexes, as expected.
4. Other Useful Properties of varStatus
Using the built-in varStatus attribute in the JSTL’s <c:forEach> tag, we’ve successfully obtained element indexes. Apart from index and count, varStatus offers other valuable properties.
Sometimes, in a loop, we need to detect whether the current element is the first or the last. For example, we want to set different background colors for the first and last movie in our HTML table.
varStatus provides two boolean properties, first and last, which allow us to easily detect if we’re in the first or the last iteration, respectively.
Next, let’s set different background colors on the first and last movie rows by checking varStatus’s first and last properties:
...
<style>
...
.first { background-color: lightgreen }
.last { background-color: orange }
</style>
...
<h1>Movie List</h1>
<div>
<table style="width: 50%">
<tr>
<th>varStatus.index</th>
<th>varStatus.count</th>
<th>Year</th>
<th>Title</th>
</tr>
<c:forEach var="movie" items="${movieList}" varStatus="theLoop">
<tr ${ theLoop.first ? 'class="first"' : '' } ${ theLoop.last ? 'class="last"' : '' }>
<td>${theLoop.index}</td>
<td>${theLoop.count}</td>
<td>${movie.year}</td>
<td>${movie.title}</td>
</tr>
</c:forEach>
</table>
</div>
...
We defined two CSS classes for the background colors. Then, in the <tr> tag, we set the corresponding class name by checking varStatus‘s first and last properties.
With this change, let’s see the result in the browser:
Now, the first row has a light green background, and the last row’s background is orange.
5. Conclusion
In this article, we’ve explored how to access an index within a <c:forEach> loop in JSP with JSTL. Whether we need zero-based indexing for logic or one-based counting for display purposes, JSTL provides an easy-to-use solution for handling loops effectively.
In addition, we demonstrated detecting the first and the last iteration in a <c:forEach> loop using varStatus‘s first and last properties.
