Java Do While Loop With Examples

The Java do while loop ensures code runs at least once before checking the condition, making it ideal for input validation and menu-driven applications.

In this blog, we’ll dive into the do while loop, showing you how it works and where to apply it in your Java programs.

Components of a Do-While Loop

Let’s break down the syntax and components of the Java do while loop to give you a comprehensive understanding of its structure and functionality. 

A do while loop in Java is structured like this: 

do {
    // block of code
} while (condition);

Here’s what each part does:

• do: The loop starts by executing the code block once, regardless of the condition. This ensures that the loop runs at least once, making it different from the regular while loop.
• Code block: The code inside the do block is what will be executed.
• while (condition): After the code block runs, the condition is evaluated. If it’s true, the loop runs again; if false, the loop stops.

Now let’s move on to how the Java do while loop actually executes and when it’s most useful. 

To further your skills in Java and software engineering, explore upGrad’s Software Engineering courses. Start building your expertise today!

How Does a Do-While Loop Execute?

In this section, you'll go through the detailed execution flow of a Java do-while loop to help you grasp its behavior and understand how it operates in different scenarios.

Here’s a do while loop example in Java: 

public class DoWhileExample {
    public static void main(String[] args) {
        int num = 1;  // Initialize the counter
        int max = 5;  // Set the upper limit

        // Do-While Loop starts
        do {
            System.out.println("Iteration " + num);  // Print the current iteration
            num++;  // Increment the counter
        } while (num <= max);  // Check the condition after each iteration
    }
}

Step-by-Step Execution Flow:

1. Initialization: The program starts with num = 1 and max = 5.
   • Comment: The variable num keeps track of the current iteration, while max sets the stopping condition for the loop.
2. First Execution of the Do Block:
   • The do block runs first before checking the condition.
   • Output: "Iteration 1" is printed because the loop starts with num = 1.
   • Action: num is then incremented by 1, so num becomes 2.
3. Condition Check: The program then checks if num <= max (2 <= 5), which is true.
   • The loop continues because the condition is true.
4. Second Iteration: The do block is executed again with num = 2.
   • Output: "Iteration 2" is printed.
   • Action: num is incremented by 1 again, so num becomes 3.
5. Subsequent Iterations: This process repeats for num = 3, num = 4, and num = 5. The output for each will be:
   • "Iteration 3", "Iteration 4", "Iteration 5".
   • The counter num keeps increasing by 1 until it reaches the value 6.
6. Final Condition Check: Once num = 6, the condition 6 <= 5 is checked and is false.
   • Since the condition is false, the do while loop stops executing.

Output: 

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

Explanation:

• First Run: The first execution happens before checking the condition, ensuring at least one run.
• Subsequent Runs: After each iteration, the condition num <= max is checked. If true, the loop continues. If false, the loop stops.
• Loop End: The loop stops once num exceeds max (after printing "Iteration 5").

Also Read: While loop in MATLAB: Everything You Need to Know

Now that you understand the execution flow of the Java do-while loop, let’s explore its practical applications and see how it’s used in different scenarios.

Practical Applications of Do-While Loop

Explore real-world applications of the Java do while loop, including menu-driven programs, input validation, and sum calculations, to understand its practical uses in Java development.

Menu-Driven Program

A do while loop example is perfect for creating a menu-driven program. Since you want the menu to display at least once, the do-while loop is the ideal choice here. 

import java.util.Scanner;

public class MenuDrivenProgram {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int choice;

        do {
            System.out.println("Menu:");
            System.out.println("1. Option 1");
            System.out.println("2. Option 2");
            System.out.println("3. Exit");
            System.out.print("Enter your choice: ");
            choice = sc.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("You chose Option 1");
                    break;
                case 2:
                    System.out.println("You chose Option 2");
                    break;
                case 3:
                    System.out.println("Exiting...");
                    break;
                default:
                    System.out.println("Invalid option! Please try again.");
            }
        } while (choice != 3); // Loop until user chooses 'Exit'

        sc.close();
    }
}

Output: 

Menu:
1. Option 1
2. Option 2
3. Exit
Enter your choice: 1
You chose Option 1
Menu:
1. Option 1
2. Option 2
3. Exit
Enter your choice: 3
Exiting...

Explanation:

• do-while loop ensures that the menu is shown at least once.
• The user is prompted to select an option. If they choose an invalid option, the loop continues until they choose to exit (choice = 3).
• The do while loop example is useful here as it guarantees the menu appears at least once, even if the user enters an invalid option.

Input Validation

Another common application of the Java do while loop is for input validation. 

If you want to ensure that the user enters valid input, you can use the do-while loop to prompt the user until they provide the correct input repeatedly. 

import java.util.Scanner;

public class InputValidation {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num;

        do {
            System.out.print("Enter a positive number: ");
            num = sc.nextInt();
            if (num <= 0) {
                System.out.println("Invalid input! Please try again.");
            }
        } while (num <= 0); // Continue looping until valid input is entered

        System.out.println("You entered a valid number: " + num);
        sc.close();
    }
}

Output: 

Enter a positive number: -5
Invalid input! Please try again.
Enter a positive number: 10
You entered a valid number: 10

Explanation:

• The do while loop example here ensures that the program keeps prompting the user until a valid number is entered.
• The loop will execute at least once, even if the user initially enters an invalid input.
• This is a practical way to validate input without repeating the code multiple times.

Sum of Natural Numbers

The Java do while loop is also useful for simple calculations, such as calculating the sum of natural numbers up to a given number. 

The loop will continue summing the numbers until the specified limit is reached. 

public class SumOfNaturalNumbers {
    public static void main(String[] args) {
        int num = 5;  // Example input
        int sum = 0;
        int i = 1;

        do {
            sum += i;  // Add the current number to sum
            i++;       // Increment the counter
        } while (i <= num); // Loop until the counter exceeds 'num'

        System.out.println("Sum of natural numbers up to " + num + " is: " + sum);
    }
}

Output: 

Sum of natural numbers up to 5 is: 15

Explanation:

• do while loop ensures that the sum is calculated at least once, starting from i = 1.
• The loop continues until the value of i exceeds num, adding each value to the sum.
• This example demonstrates how do-while loops are ideal for such cumulative tasks where you need the loop to run at least once. 

Also Read: For-Each Loop in Java [With Coding Examples]

Next, look at how you can use the loop for array iteration and complex tasks, including nested loops.

Iteration and Nesting with Do-While Loop 

The Java do while loop can efficiently iterate through arrays and be nested for complex tasks, like handling multi-dimensional arrays and matrices.

You’ll also explore the concept of nesting do-while loops, which allows you to tackle more complex tasks, such as working with multi-dimensional arrays or matrices. This technique is useful when dealing with more intricate data structures, providing you with flexibility and control over the iteration process. 

Let’s get into the different techniques: 

Iterating Through Arrays with Do-While Loop

One common use of the do while loop is iterating through arrays. Since the do while loop example always runs at least once, it’s a good fit for cases where you need to ensure an operation occurs before checking the condition.

Here’s an example of iterating through an array using a do-while loop in Java: 

public class ArrayIteration {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};  // Array to iterate over
        int index = 0;  // Start at the first index
        
        do {
            System.out.println("Element at index " + index + ": " + arr[index]);
            index++;  // Move to the next index
        } while (index < arr.length);  // Continue until all elements are processed
    }
}

Output: 

Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

Explanation:

• Array iteration: The do-while loop starts by printing the first element of the array, then increments the index until it reaches the length of the array.
• Condition check: After each iteration, the condition index < arr.length is checked to ensure the loop runs until all elements are accessed.
• This approach guarantees that every element in the array is processed, making it a good fit for tasks where you want to run through all elements in a list or array.

Nesting Do-While Loops

Now let’s look at how you can nest do-while loops to handle more complex tasks, such as iterating over multi-dimensional arrays or creating a matrix.

Here’s an example of nesting do-while loops to print the elements of a 2D array: 

public class NestedDoWhileLoop {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};  // 2D array (matrix)
        int i = 0;  // Row index
        
        do {
            int j = 0;  // Column index for each row
            do {
                System.out.print(matrix[i][j] + " ");  // Print current element
                j++;  // Move to the next column
            } while (j < matrix[i].length);  // Continue until all columns in the row are processed
            System.out.println();  // Move to the next line after each row
            i++;  // Move to the next row
        } while (i < matrix.length);  // Continue until all rows are processed
    }
}

Output: 

1 2 3 
4 5 6 
7 8 9 

Explanation:

• Nesting: The outer do-while loop handles rows of the matrix, while the inner do-while loop processes each element within a row.
• Condition checks: After each inner loop iteration, the column index (j) is incremented, and the condition checks if the column index is less than the row length.
• Matrix printing: The matrix is printed row by row, with each row being processed by the inner loop.
• At least one iteration: This method ensures that the matrix is printed completely, even if the number of rows or columns changes. 

With this understanding of array iteration and nested loops, let's now move forward to explore how the Java do while loop compares with the while loop, and when it’s best to use each one.

Do-While vs While Loop

The Java do while loop and the while loop are both used for repeating a block of code based on a condition, but they differ in how they evaluate the condition and when they execute the loop. 

Let’s break down the key differences to help you decide when to use each.

Why Use Do-While?

The Java do-while loop offers distinct benefits, especially when you need to make sure that the code block executes at least once before checking the condition.

Let’s go through some of the benefits: 

• Guarantees at least one iteration: Unlike the while loop, which may skip the loop entirely if the condition is false, the do-while loop always runs the code block once.
• Ideal for menu-driven programs: When you need to display a menu and accept user input repeatedly, you can ensure that the menu is displayed at least once, regardless of the user’s choice.
• Input validation: In scenarios where you need to prompt the user for valid input, you can validate the input after performing the task, making sure it runs at least once.
• Real-world examples: Used in cases like accepting a password, repeatedly showing a dashboard, or running a game loop.

Also Read: Control Statements in Java: What Do You Need to Know in 2024

Now, let's explore how you can enhance the flow of your loop with the break and continue statements in the do-while loop. 

Break and Continue in Do-While Loop

The break and continue statements can be used in a Java do while loop to control the flow of execution more efficiently. These statements allow you to exit the loop or skip an iteration based on specific conditions.

Let’s look at how these work: 

Using the Break Statement

The break statement is used to exit the loop completely, regardless of whether the loop’s condition has been met. This is useful when you want to stop the loop based on a specific condition, even if the loop would otherwise continue.

Let’s look at a do while loop example using break: 

public class BreakExample {
    public static void main(String[] args) {
        int num = 0;

        do {
            num++;
            if (num == 5) {
                System.out.println("Breaking the loop at num = " + num);
                break;  // Exit the loop when num reaches 5
            }
            System.out.println("Current number: " + num);
        } while (num < 10);  // Loop continues until num is less than 10
    }
}

Output:

Current number: 1
Current number: 2
Current number: 3
Current number: 4
Breaking the loop at num = 5

Explanation:

• The do-while loop example runs until num reaches 5.
• Once num becomes 5, the break statement is triggered, exiting the loop immediately, and the remaining iterations are skipped.

Using the Continue Statement

The continue statement allows you to skip the rest of the current iteration and proceed with the next iteration of the loop. This can be useful when you want to ignore certain iterations based on a condition, but still want the loop to continue running.

Here’s an example using continue: 

public class ContinueExample {
    public static void main(String[] args) {
        int num = 0;

        do {
            num++;
            if (num == 3) {
                System.out.println("Skipping num = " + num);
                continue;  // Skip the current iteration when num is 3
            }
            System.out.println("Current number: " + num);
        } while (num < 5);  // Loop runs until num is less than 5
    }
}

Output: 

Current number: 1
Current number: 2
Skipping num = 3
Current number: 4

Explanation:

• The loop prints numbers from 1 to 5, but when num is 3, the continue statement is triggered, skipping the print statement for num = 3 and moving on to the next iteration.
• The do while loop example here shows how continue can be used to skip specific conditions without exiting the loop entirely. 

With a solid understanding of break and continue, you can now refine the flow of your Java do while loop. 

Next, let’s take a look at more advanced uses of the do-while loop, including handling multiple conditions and nesting loops for complex tasks.

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

Do-While Loop with Multiple Conditions

The Java do while loop with multiple conditions, combining logical operators like AND (&&) and OR (||) allows you to control the loop's execution more precisely based on multiple criteria.

When you have more than one condition to check, you can use logical operators to combine these conditions inside the do-while loop example. This is useful when you need the loop to run based on more complex scenarios.

Here’s an example where we combine conditions using the AND operator (&&): 

public class MultipleConditionsExample {
    public static void main(String[] args) {
        int num = 1;  // Initial number
        int max = 10; // Max limit

        do {
            System.out.println("Current number: " + num);  // Print current number
            num++;  // Increment the number
        } while (num <= max && num % 2 == 0);  // Run until num is <= max and is even
    }
}

Output: 

Current number: 1

Explanation:

• The loop prints numbers as long as two conditions are met:
  • The number (num) is less than or equal to max.
  • The number is even (num % 2 == 0).
• Since num = 1 initially, the loop does not execute the second condition (num % 2 == 0), and the loop stops immediately.

Now, let’s look at an example using the OR operator (||), which allows the loop to continue if either of the conditions is true. 

public class MultipleConditionsExample2 {
    public static void main(String[] args) {
        int num = 1;  // Initial number
        int max = 10; // Max limit

        do {
            System.out.println("Current number: " + num);  // Print current number
            num++;  // Increment the number
        } while (num <= max || num % 2 == 1);  // Run while num is <= max or is odd
    }
}

Output:

Current number: 1
Current number: 2
Current number: 3
Current number: 4
Current number: 5
Current number: 6
Current number: 7
Current number: 8
Current number: 9
Current number: 10

Explanation:

• The loop continues because either condition is true:
  • num is less than or equal to max.
  • num is odd (num % 2 == 1).
• The loop continues until num exceeds max and the condition num % 2 == 1 (odd number) becomes false.

Next, let's look at how upGrad can help you advance your programming skills and take your knowledge to the next level.

How upGrad Advances Your Expertise in Programming?

Advance your Java skills with upGrad’s courses in machine learning, web development, and data structures, designed to elevate your programming expertise.

These programs provide hands-on experience, expert mentorship, and personalized feedback, helping you become job-ready and capable of tackling complex projects.

Here are some top courses offered by upGrad:

• Executive Diploma in Machine Learning and AI
• JavaScript Basics from Scratch
• Data Structures & Algorithms 
• Learn Basic Python Programming 
• Core Java Courses

For personalized career guidance, consult upGrad’s expert counselors or visit our offline centers to find the best course tailored to your goals.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software