1. Introduction
When learning Java programming, loop processing is one of the essential fundamental constructs. Among them, the continue statement is often overlooked. However, when used correctly, it can significantly improve code readability and efficiency.
By using continue, you can skip only the current iteration of a loop and proceed to the next one when a specific condition is met. This is useful, for example, when you want to exclude certain values in an array or avoid unnecessary calculations.
In this article, we explain everything from the basic usage of java continue to practical examples and differences from other loop control statements. Whether you are a beginner or an intermediate developer who has used continue without fully understanding it, this guide will help you use it with confidence.
Let’s take a step-by-step look at java continue, from basics to advanced usage.
2. Basic Syntax and Execution Flow
The continue statement is mainly used inside loops. In Java, it can be used in various loop structures such as for, while, and do-while. This section explains the basic syntax and how it works.
2-1. Basic Syntax of continue
The syntax of continue is very simple:
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // Skip this iteration when the condition is met
}
System.out.println(i);
}In this example, when i is even, continue is executed and System.out.println(i) is skipped. As a result, only odd numbers are printed.
2-2. Loop Flow and How continue Works
When continue is executed, all subsequent statements in the current loop iteration are skipped, and execution proceeds immediately to the next iteration.
Here is a simplified flow using a for loop:
- Loop initialization (e.g.,
int i = 0) - Condition check (e.g.,
i < 10) - Execute loop body
- If
continueis executed, skip remaining statements - Increment step (e.g.,
i++) - Return to step 2
In short, continue simply means “skip only the current iteration”. It is useful for clearly controlling skip conditions even in complex loops.
2-3. When Is continue Useful?
It is particularly helpful when you want to skip processing for specific conditions, such as ignoring invalid values or errors and moving on to the next iteration.
In the following sections, we will explore practical examples to demonstrate effective usage.
3. Practical Code Examples
This section introduces concrete examples using continue to help you visualize real-world usage.
3-1. Using continue in a for Loop: Skipping Specific Values
For example, if you want to skip multiples of 3 between 1 and 10:
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
continue; // Skip multiples of 3
}
System.out.println(i);
}This code outputs all numbers except 3, 6, and 9.
3-2. Using continue in a while Loop: Input Validation
When handling user input, you may want to ignore invalid values such as negative numbers:
Scanner scanner = new Scanner(System.in);
int count = 0;
while (count < 5) {
System.out.print("Please enter a positive integer: ");
int num = scanner.nextInt();
if (num < 0) {
System.out.println("Negative values are ignored.");
continue;
}
System.out.println("Entered value: " + num);
count++;
}Here, negative values are skipped and do not increment count.
3-3. Using continue in Enhanced for (for-each) Loops
You can also use continue when iterating over collections:
String[] names = {"田中", "", "佐藤", "鈴木", ""};
for (String name : names) {
if (name.isEmpty()) {
continue;
}
System.out.println(name);
}Only non-empty strings are printed.
4. Clear Differences Between continue and break
The continue statement is often compared with break, but their behavior is fundamentally different.
4-1. Key Differences
- continue: Skips the current iteration and proceeds to the next one.
- break: Terminates the entire loop immediately.
4-2. Code Comparison
continue example:
for (int i = 1; i <= 10; i++) {
if (i % 2 != 0) {
continue;
}
System.out.println(i);
}break example:
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break;
}
System.out.println(i);
}4-3. Usage Guidelines
- Use
continuewhen you want to skip part of a loop. - Use
breakwhen you want to exit the loop entirely.
5. Advanced Usage: Labeled continue
Java supports labeled continue, which allows you to specify which loop to continue in nested loops.
5-1. Basic Syntax
outerLoop:
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (j == 2) {
continue outerLoop;
}
System.out.println("i=" + i + ", j=" + j);
}
}5-2. Execution Result
i=1, j=1
i=2, j=1
i=3, j=15-3. Readability Considerations
While labeled continue can simplify nested loop control, excessive use can reduce readability. It is recommended to use it sparingly.
5-4. Risk of Infinite Loops
Be careful when skipping logic that updates loop conditions, as this can cause infinite loops.
6. Best Practices and Pitfalls
6-1. Avoid Overusing continue
Overuse can make code harder to understand.
6-2. Prevent Infinite Loops
int i = 0;
while (i < 5) {
if (i == 2) {
continue;
}
i++;
System.out.println(i);
}This code results in an infinite loop because i++ is skipped.
6-3. Team Development Considerations
Use continue carefully and document intent clearly in team environments.
6-4. Consider Alternatives
Sometimes restructuring logic or using early returns can eliminate the need for continue.
7. More Refined Alternatives
7-1. Stream API
Arrays.stream(names)
.filter(name -> !name.isEmpty())
.forEach(System.out::println);7-2. Method Decomposition
for (User user : userList) {
if (isValid(user)) {
process(user);
}
}7-3. Large-Scale Development Perspective
Readability and maintainability are prioritized, making Streams and clean design preferable.
8. Summary
8-1. Core Concept
continue skips the current iteration and moves to the next.
8-2. Difference from break
- break: exits the loop
- continue: skips one iteration
8-3. Best Practices
- Avoid excessive usage
- Prevent infinite loops
- Write readable code
8-4. Use Modern Java Features
Streams and method decomposition often provide safer alternatives.
8-5. Practice Tasks
- Skip elements conditionally
- Compare with
breakandreturn - Reimplement using Stream API
FAQ
Q1. How should I choose between continue and break?
Use continue to skip an iteration and break to exit a loop.
Q2. When should I use labeled continue?
Only when you need to skip outer loops in nested structures.
Q3. Can Stream API replace continue?
Yes, using filter achieves the same effect.
Q4. How can I avoid infinite loops?
Ensure loop counters are updated before continue.
Q5. Does continue affect performance?
No significant impact when used appropriately.
Q6. Is continue recommended in production code?
It is acceptable for simple cases, but clarity and maintainability should be prioritized.
