> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java Do-While Loop
A `do-while` loop in Java is a post-test control flow statement that guarantees the execution of a code block at least once before evaluating a boolean condition to determine subsequent iterations. Because the condition is evaluated at the end of the loop's execution path, the loop body is executed prior to any conditional checks.
**Syntax**
```java theme={"dark"}
do {
// Statements to execute
} while (booleanExpression);
```
**Execution Mechanics**
1. **Execution:** The JVM executes the statements enclosed within the `do` block sequentially.
2. **Evaluation:** The `booleanExpression` is evaluated. This expression must resolve to a `boolean` primitive (`true` or `false`).
3. **Branching:**
* If `true`, the execution pointer jumps back to the start of the `do` block.
* If `false`, the loop terminates, and the JVM proceeds to the next statement following the loop structure.
**Key Technical Characteristics**
* **Post-Test Evaluation:** The defining trait of the `do-while` loop. The condition is checked *after* the block executes, contrasting with the pre-test `while` and `for` loops where the condition is checked prior to execution.
* **Mandatory Semicolon:** The syntax strictly requires a semicolon (`;`) immediately following the `while (booleanExpression)` statement. Omitting this results in a compilation error (`error: ';' expected`).
* **Variable Scope:** Variables declared inside the `do` block are block-scoped and cannot be accessed within the `while` condition. Loop control variables evaluated in the condition must be declared in a scope prior to the `do` block.
**Code Example**
```java theme={"dark"}
int iterationCount = 0;
do {
System.out.println("Current count: " + iterationCount);
iterationCount++; // Update statement to mutate the control variable
} while (iterationCount < 3);
```
**Infinite Loop Behavior**
If the `booleanExpression` evaluates to `true` perpetually (e.g., using a boolean literal or failing to mutate the control variable within the loop body), the JVM will execute the block indefinitely, resulting in an infinite loop.
```java theme={"dark"}
do {
// Statements execute infinitely
} while (true);
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
