A nested loop has one loop inside of another. These are typically used for working with two dimensions such as printing stars in rows and columns as shown below. When a loop is nested inside another loop, the inner loop runs many times inside the outer loop. In each iteration of the outer loop, the inner loop will be re-started. The inner loop must finish all of its iterations before the outer loop can continue to its next iteration.
Example:
for(int row = 0; row < 3; row++) {
for(int col = 0; col < 5; col++) {
System.out.print("*");
}
System.out.println();
}
// This code prints a rectangle with 3 rows and 5 columns, filled with '*'
Iterating through multidimensional arrays
Nested loops are also helpful when we want to iterate through a multi dimensional array, for example:
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
This outputs each sub-element in arr one at a time. Note that for the inner loop, we are checking the .length of arr[i], since arr[i] is itself an array.
Breaking nested loops
In a nested loop, a break statement only stops the loop it is placed in. Therefore, if a break is placed in the inner loop, the outer loop still continues. For example:
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if(arr[i][j] == 3) {
break;
}
System.out.println(arr[i][j]);
}
}
// prints the numbers 1, 2, 5 and 6 on different lines
When i is 1 and j is 0, we execute the break. This means we stop the inner loop and go back to the outer loop to continue from the next iteration, which is i = 2. And as you can see, we print all the elements of row 2.
However, if the break is placed in the outer loop, all of the looping stops. For example:
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
if(arr[i][0] == 3) {
break;
}
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
// prints the numbers 1 and 2 on different lines
Assignment
Follow the Coding Tutorial and let's write some nested loops.
Hint
Look at the examples above if you get stuck.
Nested loops are a fundamental concept in programming, especially in Java. They allow you to perform complex iterations and are particularly useful for working with multi-dimensional data structures like matrices. Understanding nested loops is crucial for tasks such as data manipulation, algorithm implementation, and problem-solving in competitive programming.
Before diving into nested loops, it's essential to understand the basic structure of a loop. A loop allows you to execute a block of code multiple times. In Java, the most common types of loops are for, while, and do-while loops. Nested loops are simply loops within loops, where the inner loop completes all its iterations for each iteration of the outer loop.
Example of a simple loop:
for(int i = 0; i < 5; i++) {
System.out.println(i);
}
// This loop prints numbers from 0 to 4
Nested loops are used to handle multi-dimensional data structures. The key concept is that the inner loop runs to completion for each iteration of the outer loop. This is particularly useful for tasks like matrix manipulation, where you need to access elements in a row-column format.
Example of a nested loop:
for(int row = 0; row < 3; row++) {
for(int col = 0; col < 5; col++) {
System.out.print("*");
}
System.out.println();
}
// This code prints a rectangle with 3 rows and 5 columns, filled with '*'
Let's look at some practical examples of nested loops:
for(int row = 0; row < 3; row++) {
for(int col = 0; col < 5; col++) {
System.out.print("*");
}
System.out.println();
}
// This code prints a rectangle with 3 rows and 5 columns, filled with '*'
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
// This code prints each element of the 2D array
When working with nested loops, it's easy to make mistakes that can lead to inefficient or incorrect code. Here are some common pitfalls and best practices:
Once you're comfortable with basic nested loops, you can explore more advanced techniques such as:
Example of breaking out of nested loops:
outerLoop:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) {
break outerLoop;
}
System.out.println("i: " + i + ", j: " + j);
}
}
// This code breaks out of both loops when i == 1 and j == 1
Here is a well-commented code snippet demonstrating nested loops:
public class NestedLoopsExample {
public static void main(String[] args) {
// Example 1: Printing a rectangle of stars
for(int row = 0; row < 3; row++) {
for(int col = 0; col < 5; col++) {
System.out.print("*");
}
System.out.println();
}
// Example 2: Iterating through a 2D array
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
// Example 3: Breaking out of nested loops
outerLoop:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) {
break outerLoop;
}
System.out.println("i: " + i + ", j: " + j);
}
}
}
}
Debugging nested loops can be challenging. Here are some tips:
Example of a simple test case:
public class NestedLoopsTest {
public static void main(String[] args) {
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
assert arr[i][j] == (i * 2 + j + 1);
}
}
System.out.println("All tests passed.");
}
}
When approaching problems that require nested loops, consider the following strategies:
Nested loops are a powerful tool in Java programming. They allow you to handle complex data structures and perform intricate iterations. By mastering nested loops, you can tackle a wide range of programming challenges efficiently. Practice regularly and explore advanced techniques to become proficient in using nested loops.
For further reading and practice, consider the following resources: