skip to content

What is the empty statement in Java, and when can it cause subtle bugs?

level: middleimportance: nice to knowfreq 30%

answer

  1. Empty statement = lone ; that does nothing
  2. Legal anywhere a statement is allowed
  3. Stray ; after for/while/if header becomes the body
  4. Compiles fine, fails at runtime
  5. Always-braces style + linters defend against it

basics

~20 s

The empty statement is just a single semicolon (;) that does nothing. It is legal anywhere a statement is allowed. It causes bugs when a stray semicolon ends a loop or if early, e.g. while (cond); accidentally makes an empty loop body.

solid answer

~50 s

The empty statement is a lone semicolon that performs no action; it is a valid statement, so the compiler accepts it anywhere a statement is expected. It is occasionally used deliberately when the syntax requires a statement but you have nothing to do — for example a for loop whose work happens entirely in its header: for (i = 0; arr[i] != null; i++) ; with an empty body. The danger is accidental: a stray semicolon right after a control-flow header silently becomes the entire body. for (int i = 0; i < 10; i++); { doWork(); } runs the loop ten times doing nothing, then runs doWork() exactly once. Likewise if (x > 0); { ... } makes the if body empty and the block always executes. These compile without error and produce wrong behavior at runtime, which is why static analyzers and code style checks flag an empty statement after a loop or if header.

code

java · 12 lines
java
// BUG: stray semicolon makes an empty loop body
for (int i = 0; i < 3; i++);   // empty statement is the body
System.out.println("done");    // runs once, after the loop finishes

// BUG: empty if body
int x = -5;
if (x > 0);                    // does nothing whether x>0 or not
System.out.println("always prints"); // unconditional

// Intentional, clearer with braces:
int n = 0;
while (advance()) { /* empty body on purpose */ }

go deeper

for a junior

Recognizes that a lone semicolon is a valid do-nothing statement and that a stray one after a loop is a common bug.

for a middle

Can demonstrate the stray-semicolon bug after for/if/while, explain why it compiles, and recommend always-braces plus linting.

for a senior

Knows the legitimate header-only-loop use, names tools that detect empty statements, and distinguishes it from expression statements and empty blocks.

for a principal

Frames it as a language ergonomics trade-off (grammar simplicity vs. footgun) and drives team conventions/static-analysis policy to eliminate the class of bug.

## What it is Java recognizes a statement that is **completely empty** — just a semicolon: ```java ; ``` This is the **empty statement**. When executed it does **nothing** (no value, no effect). The reason it exists: Java's grammar has many places that require *a statement*, and sometimes you legitimately have nothing to do there, so a do-nothing statement is needed. ## Legitimate uses - A loop that does all its work in the **header**, so the body is empty: ```java int i; for (i = 0; i < arr.length && arr[i] != 0; i++) ; // empty body — the loop just advances i ``` Style guides recommend writing this empty body as `{ }` or on its own line with a comment so it's clearly intentional. - Skipping characters in a scan: `while (input.read() != -1) ;`. ## Where it bites: the stray semicolon Because the empty statement is legal, a misplaced semicolon does not cause a compile error — it silently becomes a statement. The classic traps: **1. After a loop header:** ```java for (int i = 0; i < 10; i++); // <-- this semicolon is the ENTIRE loop body { System.out.println(i); // NOT part of the loop; runs once (and i is out of scope here!) } ``` The loop runs ten times doing nothing (the empty statement), then the block runs **once**. **2. After an if condition:** ```java if (x > 0); // empty if body { System.out.println("positive"); // ALWAYS runs, regardless of x } ``` The `if` controls only the empty statement; the following block is an ordinary, unconditional block. **3. After a while header — infinite loop:** ```java int i = 0; while (i < 10); // empty body; i never changes -> infinite loop i++; // unreachable in the intended sense ``` ## Why these compile In each case the semicolon is a perfectly valid empty statement, so the grammar is satisfied; the **logic** is wrong, not the syntax. That makes the bug invisible to the compiler and visible only at runtime (wrong output, hang, or an `ArrayIndexOutOfBoundsException`). ## How to defend against it - Enable compiler/IDE warnings and static analysis (Checkstyle's `EmptyStatement`, SpotBugs, IntelliJ's "statement with empty body") — they flag an empty statement after a loop/if header. - Prefer **braces always** on control structures; an empty body is then written as `{ }` deliberately. - Code review: a semicolon immediately after `)` on an `if`/`for`/`while` line is a smell. ## Note: it is not an expression statement The empty statement is its **own** category — it contains no expression. Don't confuse it with an *expression statement* (an expression + semicolon).

  • Why doesn't if (x > 0); System.out.println("hi"); print conditionally?
    The semicolon right after the condition is the if's body (an empty statement), so the if controls nothing. The println is a separate, unconditional statement that always runs. The fix is to remove the stray semicolon (and ideally wrap the body in braces).
  • Is the empty statement an expression statement?
    No. An expression statement is an expression followed by a semicolon. The empty statement has no expression at all — it is its own grammar category that simply does nothing.

saying these in an interview costs you the question

  • Thinking a stray semicolon causes a compile error (it does not)
  • Confusing the empty statement with an expression statement
  • Assuming if (x);{...} only runs the block when x is true
  • Believing the empty statement is never useful

context

resolving links…