Java Do While Loop

Hi, today we will learn the topic of the Java Do/While Loop. You can study the material either in video format with a CodeGym mentor or in a more detailed text version with me below.

I remember when I first taught my friend Mike about Java loops. He was struggling with a program that needed to validate user input, and he kept writing these convoluted if-statements with multiple checks. I showed him the do-while loop, and man, I won't ever forget the way his face changed. He kinda smirked and went, "Hold up... so I can just keep bugging them till they actually give me the right stuff?" Yep, you got it, Mike. That's exactly what makes the do-while loop so darn useful.

Introduction

You know those situations where you absolutely gotta run some code once – no ifs, ands, or buts? Like when you're building those menu screens and need the user to see their options first, or when you're trying to get valid input and don't wanna check if it's good until after they've had a shot at entering something? Do-while loops are your best friend there. The regular while loop is super cautious – it won't even step through the door without checking conditions first. But do-while? That's your buddy who jumps in the pool then asks how deep it is. Runs the code block first, then checks if it should keep going. I've been using these things for years – in coding interviews, classroom projects, real-world apps – and lemme tell ya, once you really get how do-while loops work, your code gets way cleaner. Trust me on this one. Let's get into it!

What is a Java Do/While Loop?

So what exactly is this thing? In plain English, a do-while loop is basically Java's way of saying "do this stuff at least once, then keep doing it as long as some condition stays true."

Syntax

Here's how it looks—nice and clean:

Java

do {
    // Stuff you want to happen
} while (condition);

See that little semicolon at the end? Don't skip it! I've watched folks tear their hair out debugging for hours, only to realize they forgot that tiny mark. It's like the period at the end of a sentence—Java needs it to know you're done.

Here's the play-by-play:

The stuff inside do { } runs first, no hesitation.
Then it checks the condition.
If it's true, back to the top we go.
If it's false, we're outta there.

Simple Example

Check this out:

Java

int count = 1;
do {
    System.out.println("Count's at: " + count);
    count++;
} while (count <= 5);

What'll you see?

Count's at: 1
Count's at: 2
Count's at: 3
Count's at: 4
Count's at: 5

Now, here's the cool part—even if I start with something wacky like count = 10, it still runs once:

Java

int count = 10;
do {
    System.out.println("Count's at: " + count);
    count++;
} while (count <= 5);

Output:

Count's at: 10

Flowchart

Wanna see how it flows? Imagine this:

Start → Run the code → Check condition? → Yes → Back to run code
                         ↓ No
                         Exit

It's like a kid jumping into a game, then asking, "Should I keep playing?"

How Does It Work?

Let's get hands-on and see this thing in action with something practical.

Step-by-Step Example

Here's one I've used to mess around with numbers:

Java

int number = 1;
do {
    System.out.println("Number's at: " + number);
    number *= 2;
} while (number < 20);

Let's walk through it like we're debugging together:

Round	number Before	What Happens	number After	number < 20?	Next Move
1	1	Prints "Number's at: 1", doubles it	2	Yup (2 < 20)	Keep going
2	2	Prints "Number's at: 2", doubles it	4	Yup (4 < 20)	Keep going
3	4	Prints "Number's at: 4", doubles it	8	Yup (8 < 20)	Keep going
4	8	Prints "Number's at: 8", doubles it	16	Yup (16 < 20)	Keep going
5	16	Prints "Number's at: 16", doubles it	32	Nope (32 < 20)	Stop

Output:

Number's at: 1
Number's at: 2
Number's at: 4
Number's at: 8
Number's at: 16

User Input Validation Example

Here's where do-while shines—like when I'm forcing someone (politely!) to give me good input:

Java

import java.util.Scanner;

public class InputCheck {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int userNumber;

        do {
            System.out.print("Gimme a positive number: ");
            userNumber = scanner.nextInt();
            if (userNumber <= 0) {
                System.out.println("C'mon, that's not positive. Try again!");
            }
        } while (userNumber <= 0);

        System.out.println("Sweet! You gave me: " + userNumber);
        scanner.close();
    }
}

It's like a bouncer at a club—keeps asking for ID until you show the right one.

Do/While vs. While Loop

So, how's this different from a regular while loop? Let's put them head-to-head.

Syntax Side-by-Side

While Loop:

Java

while (condition) {
    // Stuff happens here
}

Do-While Loop:

Java

do {
    // Stuff happens here
} while (condition);

The big difference? While checks the condition first—like knocking before entering. Do-while just barges in, does its thing, then checks if it should stick around.

When to Pick One

Here's my rule of thumb:

While loop: Use it when you might not even need to run the code—like checking if a file's there before reading it.
Do-while loop: Go for it when you've gotta run something once—like showing a menu before asking what they want.

Quick Comparison

Watch this:

Java

int i = 10;
System.out.println("With while:");
while (i < 5) {
    System.out.println("i is: " + i);
    i++;
}

i = 10;
System.out.println("\nWith do-while:");
do {
    System.out.println("i is: " + i);
    i++;
} while (i < 5);

Output:

With while:

With do-while:
i is: 10

While didn't even bother, but do-while gave it a shot.

Same Problem, Two Ways

Here's a classic: Make someone pick a number between 1 and 10.

While Way:

Java

import java.util.Scanner;

public class WhileWay {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number = 0;

        System.out.print("Pick a number 1-10: ");
        number = scanner.nextInt();

        while (number < 1 || number > 10) {
            System.out.println("Nope, that's off!");
            System.out.print("Try again (1-10): ");
            number = scanner.nextInt();
        }

        System.out.println("Nice one! You picked: " + number);
        scanner.close();
    }
}

Do-While Way:

Java

import java.util.Scanner;

public class DoWhileWay {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number;

        do {
            System.out.print("Pick a number 1-10: ");
            number = scanner.nextInt();
            if (number < 1 || number > 10) {
                System.out.println("Hey, stick to the rules!");
            }
        } while (number < 1 || number > 10);

        System.out.println("Awesome! You picked: " + number);
        scanner.close();
    }
}

The do-while version feels smoother—no repeated prompt outside the loop.

Real Stuff You'll Use This For

Let's talk about where this actually saves your bacon.

1. Menus That Don't Suck

I built an inventory app for a pal's shop once, and the menu was a mess until I slapped a do-while on it:

Java

import java.util.Scanner;

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

        do {
            System.out.println("\n=== Shop Menu ===");
            System.out.println("1. Check Stock");
            System.out.println("2. Add Item");
            System.out.println("3. Update Item");
            System.out.println("4. Remove Item");
            System.out.println("5. Quit");
            System.out.print("What's your pick (1-5)? ");

            choice = scanner.nextInt();

            switch (choice) {
                case 1: System.out.println("Checking stock..."); break;
                case 2: System.out.println("Adding item..."); break;
                case 3: System.out.println("Updating item..."); break;
                case 4: System.out.println("Removing item..."); break;
                case 5: System.out.println("See ya!"); break;
                default: System.out.println("Huh? Try again.");
            }
        } while (choice != 5);

        scanner.close();
    }
}

2. Network Retries

Ever had to ping a server that's being flaky? Here's how I'd retry:

Java

import java.io.IOException;
import java.net.Socket;

public class NetworkPing {
    public static void main(String[] args) {
        String host = "example.com";
        int port = 80;
        int tries = 0;
        int maxTries = 5;
        boolean connected = false;

        do {
            System.out.println("Trying " + host + ":" + port + " (Try " + (tries + 1) + " of " + maxTries + ")");
            try {
                Socket socket = new Socket(host, port);
                connected = true;
                System.out.println("Got it!");
                socket.close();
            } catch (IOException e) {
                System.out.println("No dice: " + e.getMessage());
                tries++;
                try {
                    Thread.sleep(1000); // Chill for a sec
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                }
            }
        } while (!connected && tries < maxTries);

        if (!connected) {
            System.out.println("Couldn't connect after " + maxTries + " shots.");
        }
    }
}

Common Mistakes and Debugging Tips

I've seen these slip-ups a million times teaching Java—let's dodge them.

1. Missing That Semicolon

Java

// Wrong
do {
    System.out.println("This flops");
} while (true)  // No semicolon, big oops!

// Right
do {
    System.out.println("This works");
} while (true);  // Semicolon saves the day

2. Loops That Never Quit

Java

int count = 1;
do {
    System.out.println("Count's: " + count);
    // Forgot to bump count—stuck forever!
} while (count < 10);

Fix it by moving the needle:

Java

int count = 1;
do {
    System.out.println("Count's: " + count);
    count++;
} while (count < 10);

3. Off-by-One Mess-Ups

Java

int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);  // Goes to 10, prints 11 times

// Fix for 1-10
int i = 1;
do {
    System.out.println(i);
    i++;
} while (i < 11);

Debugging Hacks

When it's acting weird:

Toss in some System.out.println("count = " + count); to spy on variables.
Use your IDE's debugger to step through—watch it live.
Cap it with a counter to avoid infinite chaos:

Java

int tries = 0;
do {
    // Code
    tries++;
    if (tries > 1000) {
        System.out.println("Whoa, too many loops!");
        break;
    }
} while (condition);

Challenge for Readers

Ready to flex those skills? Try this:

Number Guessing Game

Make a game where:

The computer picks a random number (1-100).
You guess until you nail it.
It tells you "higher" or "lower" each time.

Start here:

Java

import java.util.Scanner;
import java.util.Random;

public class GuessGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        int secret = random.nextInt(100) + 1;
        int guess;
        int tries = 0;

        System.out.println("I've got a number between 1 and 100. Guess it!");
        // Add your do-while magic here

        scanner.close();
    }
}

My Solution

Here's how I'd do it:

Java

import java.util.Scanner;
import java.util.Random;

public class GuessGameSolution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        int secret = random.nextInt(100) + 1;
        int guess;
        int tries = 0;

        System.out.println("I've got a number between 1 and 100. Guess it!");

        do {
            System.out.print("Your guess: ");
            guess = scanner.nextInt();
            tries++;

            if (guess < secret) {
                System.out.println("Go higher!");
            } else if (guess > secret) {
                System.out.println("Go lower!");
            } else {
                System.out.println("You nailed it in " + tries + " tries!");
            }
        } while (guess != secret);

        scanner.close();
    }
}

Conclusion

The do-while loop is a powerful control structure in Java that guarantees at least one execution of a code block before checking a condition. This makes it ideal for scenarios like menu systems, user input validation, and situations where you need to act first and check conditions later.

Unlike the while loop, which may not execute at all if the initial condition is false, the do-while loop always executes its body at least once. This subtle difference can lead to cleaner code in many situations.

Remember the key points we've covered:

Use do-while when you need at least one execution
Don't forget the trailing semicolon
Be careful to update your loop control variables to avoid infinite loops
Pay attention to boundary conditions to prevent off-by-one errors

By mastering the do-while loop, you've added another essential tool to your Java programming toolkit. Want to continue your Java learning journey? Check out our comprehensive Java course at CodeGym, where you'll find interactive challenges, practical projects, and a supportive community to help you become a confident Java developer.

Ready to master Java loops and more? Start your learning journey today!