🔄 Java Tutorial: Loops in Java

📘 Introduction to Java Loops

Loops are fundamental to programming. They allow us to execute a block of code multiple times, reducing redundancy and making our programs more efficient and concise.

In Java, the core looping constructs include:

  • for loop
  • while loop
  • do-while loop
  • Enhanced for-each loop (for arrays and collections)

💡 Why Java Loops Matter: Common Use Cases

Loops are vital for:

  • 🔁 Repeating tasks (e.g., printing messages, calculating sums)
  • 📋 Traversing arrays or collections
  • 🎮 Game logic (e.g., turn-based loops)
  • 🧠 Algorithm implementation (e.g., searching, sorting)
  • 📊 Generating reports, tables, or outputs dynamically

🔍 Types of Loops in Java Programming

🔹 1. Java For Loop

The for loop is used when the number of iterations is known beforehand. It consists of three parts: initialization, condition, and update.

Syntax:

for (initialization; condition; update) {
    // code to be executed
}

Example:

for (int i = 1; i <= 5; i++) {
    System.out.println("Iteration: " + i);
}

📝 Detailed Explanation:

  • Initialization: int i = 1 - Executes once at the beginning
  • Condition: i <= 5 - Checked before each iteration
  • Update: i++ - Executes after each iteration
  • Execution Flow:
    1. Initialize i to 1
    2. Check if i <= 5 (true)
    3. Execute the loop body
    4. Increment i to 2
    5. Repeat steps 2-4 until condition is false

Advanced Example - Counting Backwards:

for (int i = 10; i > 0; i--) {
    System.out.println("Countdown: " + i);
}
System.out.println("Blast off!");

🔹 2. Java While Loop: Condition-Based Iteration

The while loop is used when the number of iterations is not known in advance and depends on a condition that is evaluated before each iteration.

Syntax:

while (condition) {
    // code to be executed
}

Example:

int i = 1;
while (i <= 5) {
    System.out.println("i = " + i);
    i++;
}

📝 Detailed Explanation:

  • The condition i <= 5 is checked before each iteration
  • If the condition is true, the loop body executes
  • If the condition is false initially, the loop body never executes
  • The update statement i++ must be included in the loop body to avoid infinite loops

Real-world Example - Reading User Input:

Scanner scanner = new Scanner(System.in);
String input = "";
while (!input.equalsIgnoreCase("quit")) {
    System.out.print("Enter command (type 'quit' to exit): ");
    input = scanner.nextLine();
    System.out.println("You entered: " + input);
}

🔹 3. Java Do-While Loop: Execute-Then-Check

The do-while loop is similar to the while loop, but it guarantees that the loop body executes at least once, regardless of the condition.

Syntax:

do {
    // code to be executed
} while (condition);

Example:

int i = 1;
do {
    System.out.println("i = " + i);
    i++;
} while (i <= 5);

📝 Detailed Explanation:

  • The loop body executes first
  • Then the condition i <= 5 is checked
  • If the condition is true, the loop continues
  • If the condition is false, the loop terminates
  • Even if the condition is false initially, the loop body executes once

Menu-driven Example:

Scanner scanner = new Scanner(System.in);
int choice;
do {
    System.out.println("\nMenu:");
    System.out.println("1. Add");
    System.out.println("2. Subtract");
    System.out.println("3. Exit");
    System.out.print("Enter your choice: ");
    choice = scanner.nextInt();
    
    switch (choice) {
        case 1: System.out.println("Addition selected"); break;
        case 2: System.out.println("Subtraction selected"); break;
        case 3: System.out.println("Exiting..."); break;
        default: System.out.println("Invalid choice");
    }
} while (choice != 3);

🔹 4. Java For-Each Loop: Enhanced Array Iteration

The enhanced for loop (also called for-each loop) simplifies iteration over arrays and collections when you need to access each element without caring about the index.

Syntax:

for (elementType element : collection) {
    // code to be executed
}

Example with Array:

String[] colors = {"Red", "Green", "Blue"};
for (String color : colors) {
    System.out.println(color);
}

Example with Collection:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
for (Integer number : numbers) {
    System.out.println(number * number);
}

📝 Detailed Explanation:

  • No initialization, condition, or update expressions
  • Automatically iterates through each element in the collection
  • Cannot modify the collection structure during iteration
  • Cannot access the index of the current element
  • More readable and less error-prone for simple iterations

📦 Nested Loops in Java

Nested loops are loops within loops, commonly used for working with multi-dimensional data structures or generating complex patterns.

Example - Printing a Pattern:

for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

Output:

* 
* * 
* * * 
* * * * 
* * * * *

Example - Processing a 2D Array:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

📝 Performance Consideration:

  • Nested loops have O(n²) time complexity for two loops
  • Be cautious with deeply nested loops (3+) as they can significantly impact performance

🔄 Java Loop Control Statements

break Statement

Terminates the loop immediately and continues execution after the loop.

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // Exit the loop when i equals 5
    }
    System.out.println(i);
}
// Output: 1 2 3 4

continue Statement

Skips the current iteration and proceeds to the next iteration.

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // Skip even numbers
    }
    System.out.println(i);
}
// Output: 1 3 5 7 9

⚠️ Common Pitfalls in Java Loops

  • ❗ Infinite loops: Forgetting to update the loop variable or using incorrect conditions

    // Infinite loop example
while (true) {
    System.out.println("This will run forever!");
    // No break condition
}

  • ❗ Off-by-one errors: Using <= vs < incorrectly

    // Array has indices 0-9
int[] array = new int[10];

// Correct
for (int i = 0; i < array.length; i++) { /* ... */ }

// Incorrect - causes ArrayIndexOutOfBoundsException
for (int i = 0; i <= array.length; i++) { /* ... */ }

  • ❗ Modifying collections during iteration

    // This will throw ConcurrentModificationException
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
for (Integer number : numbers) {
    if (number % 2 == 0) {
        numbers.remove(number); // Don't do this!
    }
}

// Correct approach using Iterator
Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    Integer number = iterator.next();
    if (number % 2 == 0) {
        iterator.remove(); // Safe removal
    }
}

  • ❗ Forgetting to initialize variables

    // This won't compile
int sum;
for (int i = 1; i <= 10; i++) {
    sum += i; // Error: variable sum might not have been initialized
}

// Correct
int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum += i;
}

✅ Best Practices

  • ✅ Choose the right loop for the job

    • for → Known number of iterations
    • while → Unknown number, pre-check
    • do-while → At least one execution
    • for-each → Simple iteration over collections

  • ✅ Use meaningful variable names

    // Poor
for (int x = 0; x < arr.length; x++) { /* ... */ }

// Better
for (int index = 0; index < employees.length; index++) { /* ... */ }

  • ✅ Keep loop bodies small and focused

    • Consider extracting complex logic into separate methods

  • ✅ Avoid deep nesting

    • More than 3 levels of nesting becomes hard to read
    • Extract inner loops into separate methods

  • ✅ Be careful with loop boundaries

    • Double-check array indices
    • Use < array.length instead of <= array.length - 1

  • ✅ Add exit conditions clearly

    while (condition) {
    // processing
    if (exitCondition) {
        break;
    }
}

🔍 Advanced Java Loop Techniques

🧠 Multiple Variables in Java For Loop

for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println("i = " + i + ", j = " + j);
}
// Output:
// i = 0, j = 10
// i = 1, j = 9
// i = 2, j = 8
// i = 3, j = 7
// i = 4, j = 6

🧵 Using Labels for Loop Control

Labels allow you to break or continue specific outer loops from within nested loops.

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer; // Breaks out of both loops
        }
        System.out.println("i=" + i + " j=" + j);
    }
}

🔄 Stream APIs vs Traditional Loops

Java 8+ offers Stream API as a modern alternative to loops for collection processing.

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Traditional loop
for (String name : names) {
    if (name.length() > 4) {
        System.out.println(name.toUpperCase());
    }
}

// Stream API equivalent
names.stream()
     .filter(name -> name.length() > 4)
     .map(String::toUpperCase)
     .forEach(System.out::println);

⚙️ Parallel Processing with Loops

// Sequential processing
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.forEach(n -> heavyComputation(n));

// Parallel processing
numbers.parallelStream()
       .forEach(n -> heavyComputation(n));

📝 Summary / Key Takeaways

  • Loops help automate repetitive tasks and are essential for efficient programming
  • Each loop type has specific use cases:
    • for → Known number of iterations
    • while → Unknown number, pre-check
    • do-while → At least one execution
    • for-each → Simple iteration over collections
  • Loop control statements (break, continue) provide additional flexibility
  • Watch out for common pitfalls like infinite loops and off-by-one errors
  • Modern Java offers Stream API as a functional alternative to traditional loops
  • Mastering loops leads to better logic-building and algorithm design

🧪 Exercises / Mini-Projects

🎯 Practice 1: Multiplication Table

int num = 5;
System.out.println("Multiplication table for " + num + ":");
for (int i = 1; i <= 10; i++) {
    System.out.println(num + " x " + i + " = " + (num * i));
}

📊 Practice 2: Sum of Digits

int number = 1234;
int sum = 0;
while (number != 0) {
    sum += number % 10;  // Add the last digit to sum
    number /= 10;        // Remove the last digit
}
System.out.println("Sum of digits: " + sum);  // Output: 10 (1+2+3+4)

🔢 Practice 3: Fibonacci Series

int n = 10;
int first = 0, second = 1;
System.out.print("Fibonacci Series: " + first + ", " + second);

for (int i = 2; i < n; i++) {
    int next = first + second;
    System.out.print(", " + next);
    first = second;
    second = next;
}

📝 Practice 4: Pattern Printing

int rows = 5;
for (int i = 1; i <= rows; i++) {
    // Print spaces
    for (int j = rows; j > i; j--) {
        System.out.print(" ");
    }
    // Print stars
    for (int k = 1; k <= (2 * i - 1); k++) {
        System.out.print("*");
    }
    System.out.println();
}

💻 Try these challenges:

  • 🔄 Create a for loop that prints prime numbers from 1 to 100
  • 🔠 Reverse a string using a for loop
  • 📚 Loop through a 2D array and find the largest element
  • 📦 Create a menu-driven system using do-while and switch
  • 🔁 Implement FizzBuzz using all loop styles
  • 📈 Write a program to find the factorial of a number using a loop
  • 🧮 Create a simple calculator that keeps running until the user chooses to exit

🎉 Mastering loops is a cornerstone in Java programming — it leads you to clean, logical, and efficient code. Practice regularly and apply loops in building real-world logic to become fluent!

Control Flow
Defining Methods