Home » Tutorials » Control Statements
Category:

Control Statements

Control Statements

Java break and continue Statements Tutorial

written by 75ypsaw71

In Java, the break and continue statements are used to control the flow of loops (for, while, do-while) and switch statements.

They provide ways to exit from a loop or skip certain iterations based on a condition.

In this tutorial, we’ll cover the usage of both break and continue statements with examples to demonstrate their behavior in different scenarios.

1. The break Statement

The break statement is used to exit a loop or a switch statement immediately. Once the break is encountered, the control jumps to the first statement outside the loop or switch block.

Syntax:

break;

Common Use Cases:

Exiting a loop early when a certain condition is met.
Exiting a switch case to avoid falling through to the next case.

Example 1: Using break in a for Loop

public class BreakInForLoop {
    public static void main(String[] args) {
        // For loop example
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break;  // Exit the loop when i is 5
            }
            System.out.println(i);
        }
    }
}

Explanation:

The for loop iterates from 1 to 10.
The break statement exits the loop when i == 5.

Output:

1
2
3
4

Example 2: Using break in a while Loop

public class BreakInWhileLoop {
    public static void main(String[] args) {
        int i = 1;

        while (i <= 10) {
            if (i == 6) {
                break;  // Exit the loop when i is 6
            }
            System.out.println(i);
            i++;
        }
    }
}

Explanation:

The while loop continues until i reaches 10.
The break statement exits the loop when i == 6.

Output:

1
2
3
4
5

Example 3: Using break in a switch Statement

public class BreakInSwitchStatement {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;  // Exits the switch after this case
            case 4:
                System.out.println("Thursday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

Explanation:

The switch statement checks the value of day.
When day == 3, it prints “Wednesday” and exits the switch block using break.

Output:
Wednesday.

2. The continue Statement

The continue statement is used to skip the current iteration of a loop and move to the next iteration. Unlike break, it does not exit the loop but skips the remaining code inside the loop for that specific iteration.

Syntax:

continue;

Common Use Cases:

Skipping certain iterations in a loop based on a condition.

Example 4: Using continue in a for Loop

public class ContinueInForLoop {
    public static void main(String[] args) {
        // For loop example
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue;  // Skip the even numbers
            }
            System.out.println(i);
        }
    }
}

Explanation:

The for loop iterates from 1 to 10.
The continue statement skips the current iteration when i is even (i.e., i % 2 == 0).

Output:

1
3
5
7
9

Example 5: Using continue in a while Loop

public class ContinueInWhileLoop {
    public static void main(String[] args) {
        int i = 0;

        while (i < 10) {
            i++;

            if (i % 3 == 0) {
                continue;  // Skip numbers divisible by 3
            }
            System.out.println(i);
        }
    }
}

Explanation:

The while loop continues as long as i < 10.
When i is divisible by 3, the continue statement skips the print statement and moves to the next iteration.

Output:

1
2
4
5
7
8
10

Example 6: Nested Loops with continue and break

In nested loops, break and continue affect only the innermost loop where they are used.

public class NestedLoops {
    public static void main(String[] args) {
        // Outer loop
        for (int i = 1; i <= 3; i++) {
            // Inner loop
            for (int j = 1; j <= 3; j++) {
                if (i == j) {
                    continue;  // Skip when i == j
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

Explanation:

The outer loop runs from 1 to 3.
The inner loop also runs from 1 to 3.
The continue statement skips printing when i == j.

Output:

i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2

3. Breaking and Continuing in Labeled Loops

Java allows the use of labeled loops, where a label is given to a loop, and you can break or continue that specific loop from within nested loops.

Syntax:

labelName:
for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        if (condition) {
            break labelName;  // Exits the labeled loop
        }
    }
}

Example 7: Using break with Labeled Loops

public class BreakWithLabel {
    public static void main(String[] args) {
        // Labeled outer loop
        outerLoop:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    break outerLoop;  // Exit the outer loop when i == 2 and j == 2
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

Explanation:

The break outerLoop exits both the inner and outer loops when i == 2 and j == 2.

Output:

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
Example 8: Using continue with Labeled Loops
public class ContinueWithLabel {
    public static void main(String[] args) {
        // Labeled outer loop
        outerLoop:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    continue outerLoop;  // Skip the inner loop and go to the next iteration of outer loop
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }
}

Explanation:

The continue outerLoop skips the remaining iterations of the inner loop when i == 2 and j == 2 and moves to the next iteration of the outer loop.

Output:

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3

Conclusion

The break and continue statements provide powerful control over the flow of loops in Java:

break: Used to exit a loop or switch statement immediately.
continue: Used to skip the current iteration of a loop and continue with the next iteration.
Labeled loops allow you to specify which loop to break or continue when dealing with nested loops.

By understanding these control structures, you can write more flexible and efficient code.

0 comment
0 FacebookTwitterPinterestEmail
Control Statements

Java for-each Loop: A Comprehensive Tutorial with Code Examples

written by 75ypsaw71

The for-each loop in Java is a simplified version of the for loop that is specifically designed for iterating over collections such as arrays, ArrayLists, and other data structures that implement the Iterable interface. The for-each loop enhances readability by eliminating the need for a loop counter or index management.

This tutorial will guide you through the concept, usage, and best practices of the for-each loop in Java with detailed examples.

Table of Contents:

1. What is the for-each Loop?

The for-each loop (also known as the enhanced for loop) is a convenient way to iterate through elements in a collection (arrays, ArrayList, HashSet, etc.) without needing to explicitly manage an index or iterator. It’s especially useful when you don’t need to know the index of the current element.

2. Syntax of the for-each Loop

General Syntax:

for (Type element : collection) {
    // Code to process each element
}

Type: The data type of the elements in the collection.
element: The variable that represents the current element during each iteration.
collection: The array, ArrayList, HashSet, or any iterable collection you want to loop over.

3. Using for-each Loop with Arrays

You can use the for-each loop to iterate through arrays of any type (primitive types and objects).

Example 1: Iterating Over an Array of Integers

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

Output:

1
2
3
4
5

In this example, the for-each loop iterates through the numbers array, and each element is printed.

Example 2: Iterating Over an Array of Strings

public class Main {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry", "Date"};

        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output:

Apple
Banana
Cherry
Date

Here, the for-each loop iterates over the fruits array and prints each fruit name.

4. Using for-each Loop with Collections (ArrayList, Set, etc.)

The for-each loop is commonly used with collections like ArrayList, HashSet, and other classes from the Java Collections Framework.

Example 3: Iterating Over an ArrayList

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList names = new ArrayList<>();
        names.add("John");
        names.add("Jane");
        names.add("Alex");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

Output:

John
Jane
Alex

The for-each loop makes it easy to iterate over the ArrayList without needing to manage the index.

Example 4: Iterating Over a HashSet

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

Output:

10
20
30

In this example, we use a for-each loop to iterate over a HashSet. The iteration order in a HashSet is not guaranteed.

5. Using for-each with Map Entries

A Map stores key-value pairs, and you can use the for-each loop to iterate through the entries in a Map.

Example 5: Iterating Over a HashMap

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> scores = new HashMap<>();
        scores.put("John", 85);
        scores.put("Jane", 90);
        scores.put("Alex", 78);

        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Output:

John: 85
Jane: 90
Alex: 78

Here, the for-each loop iterates over the Map.Entry elements of the HashMap, printing both keys and values.

6. for-each vs Traditional for Loop

The traditional for loop provides more control over the iteration (for example, using an index to modify elements), but the for-each loop simplifies iteration and reduces the chance of errors.

Example 6: Traditional for Loop vs for-each Loop

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        // Traditional for loop
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Traditional: " + numbers[i]);
        }

        // For-each loop
        for (int number : numbers) {
            System.out.println("For-each: " + number);
        }
    }
}

Output:

Traditional: 1
Traditional: 2
Traditional: 3
Traditional: 4
Traditional: 5
For-each: 1
For-each: 2
For-each: 3
For-each: 4
For-each: 5

Traditional for loop: You manage the index manually (i), which is useful if you need to modify elements or access the index.
for-each loop: Simpler and more readable when you just need to access elements.

7. Using break and continue in for-each Loop

You can use break to terminate the loop prematurely and continue to skip the current iteration and move to the next one.

Example 7: Using break in for-each Loop

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int number : numbers) {
            if (number == 4) {
                break;  // Exit the loop when the number is 4
            }
            System.out.println(number);
        }
    }
}

Output:

1
2
3

In this example, the loop stops when number equals 4 due to the break statement.

Example 8: Using continue in for-each Loop

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int number : numbers) {
            if (number % 2 == 0) {
                continue;  // Skip even numbers
            }
            System.out.println(number);
        }
    }
}

Output:

1
3
5

In this example, the continue statement skips even numbers, and only odd numbers are printed.

8. Best Practices for Using for-each Loop

Use for-each for readability: When you simply need to iterate through elements without modifying them or using the index, the for-each loop is the best choice for readability.

Avoid modifying elements: If you need to modify the elements of an array or list, a traditional for loop might be a better option because the for-each loop does not provide access to the index.

Use break and continue carefully: While these can help control loop execution, overusing them can reduce code clarity.

9. Common Use Cases

Example 9: Summing Array Elements

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int sum = 0;

        for (int number : numbers) {
            sum += number;
        }

        System.out.println("Sum: " + sum);
    }
}

Output:

Sum: 15

In this example, we use a for-each loop to sum the elements in an array.

Example 10: Searching in a Collection

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList names = new ArrayList<>();
        names.add("John");
        names.add("Jane");
        names.add("Alex");

        for (String name : names) {
            if (name.equals("Jane")) {
                System.out.println("Found Jane!");
                break;  // Exit the loop once "Jane" is found
            }
        }
    }
}

Output:

Found Jane!

This example shows how to search for an element in a collection using a for-each loop and exit the loop once the element is found.

Conclusion

The for-each loop in Java is a simple and efficient way to iterate over arrays and collections. It eliminates the need for managing indexes or iterators manually, making your code more readable and less prone to errors.

While it may not be suitable for every scenario (such as when modifying elements or needing the index), it is a great choice for most iteration tasks, especially when working with collections like ArrayList, HashSet, and Map.

By following best practices and understanding when to use the for-each loop, you can write clean and efficient Java code.

0 comment
0 FacebookTwitterPinterestEmail
Control Statements

Java do-while Loop: A Comprehensive Tutorial with Code Examples

written by 75ypsaw71

The do-while loop in Java is a variant of the while loop that ensures the code block inside the loop is executed at least once, regardless of whether the condition is true or false.

This tutorial will cover how the do-while loop works, its syntax, and examples to illustrate different scenarios where it can be used effectively.

Table of Contents:

1. Introduction to do-while Loop

The do-while loop is a control flow statement that executes a block of code once, then checks a condition. If the condition is true, the loop continues executing the block. This ensures that the code inside the loop runs at least once, even if the condition is initially false.

2. Syntax of do-while Loop

General Syntax:

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

do: The code inside the do block is executed first.
while: After the execution of the block, the condition is evaluated. If true, the loop repeats; if false, the loop terminates.

3. Basic Example of do-while Loop

Example 1: Basic do-while Loop

public class Main {
    public static void main(String[] args) {
        int count = 1;

        do {
            System.out.println("Count: " + count);
            count++;
        } while (count <= 5);
    }
}

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

In this example:

The loop executes the block once, and after each iteration, it checks whether count is still less than or equal to 5.
The loop runs five times and prints the value of count in each iteration.

4. do-while Loop vs while Loop

The key difference between the do-while loop and the while loop is that the do-while loop executes the code at least once, even if the condition is false. In contrast, the while loop evaluates the condition before executing the loop body.

Example 2: do-while vs while Loop

public class Main {
    public static void main(String[] args) {
        int count = 10;

        // Using while loop
        while (count < 5) {
            System.out.println("While Loop: Count is " + count);
        }

        // Using do-while loop
        do {
            System.out.println("Do-While Loop: Count is " + count);
        } while (count < 5);
    }
}

Output:

Do-While Loop: Count is 10

In this example:

The while loop doesn’t execute because the condition count < 5 is false.
The do-while loop runs once even though the condition is false.

5. Common Use Cases for do-while Loop

The do-while loop is often used when the loop needs to execute at least once, such as in the following scenarios:

Example 3: User Input Validation

A common use case is to prompt the user for input repeatedly until they provide valid input.

import java.util.Scanner;

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

        do {
            System.out.println("Enter a number between 1 and 10:");
            number = scanner.nextInt();
        } while (number < 1 || number > 10);

        System.out.println("You entered: " + number);
    }
}

Output (Example inputs: 12, then 5):

Enter a number between 1 and 10:
12
Enter a number between 1 and 10:
5
You entered: 5

In this example, the do-while loop ensures that the user is prompted at least once, and the loop repeats until the user enters a valid number.

Example 4: Repeated Menu Display

A do-while loop can be useful for repeatedly showing a menu to the user until they choose to exit.

import java.util.Scanner;

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

        do {
            System.out.println("Menu:");
            System.out.println("1. Start");
            System.out.println("2. Settings");
            System.out.println("3. Exit");
            System.out.print("Choose an option: ");
            choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("Starting...");
                    break;
                case 2:
                    System.out.println("Opening settings...");
                    break;
                case 3:
                    System.out.println("Exiting...");
                    break;
                default:
                    System.out.println("Invalid choice, please try again.");
            }
        } while (choice != 3);
    }
}

Output (Example input: 1, then 3):

Menu:
1. Start
2. Settings
3. Exit
Choose an option: 1
Starting...
Menu:
1. Start
2. Settings
3. Exit
Choose an option: 3
Exiting...

In this example, the menu is displayed repeatedly until the user selects the option to exit (choice 3).

6. Using break and continue with do-while

You can use break and continue to control the flow within a do-while loop.

break: Immediately terminates the loop.
continue: Skips the current iteration and moves to the next iteration.

Example 5: Using break with do-while

public class Main {
    public static void main(String[] args) {
        int count = 1;

        do {
            System.out.println("Count: " + count);
            if (count == 3) {
                break;  // Exit the loop when count is 3
            }
            count++;
        } while (count <= 5);
    }
}

Output:

Count: 1
Count: 2
Count: 3

In this example, the loop terminates when count reaches 3 due to the break statement.

Example 6: Using continue with do-while

public class Main {
    public static void main(String[] args) {
        int count = 0;

        do {
            count++;

            if (count % 2 == 0) {
                continue;  // Skip even numbers
            }

            System.out.println("Odd number: " + count);
        } while (count < 10);
    }
}

Output:

Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9

In this example, the continue statement skips even numbers and only prints odd numbers.

7. Nested do-while Loops

You can nest one do-while loop inside another to handle more complex scenarios.

Example 7: Nested do-while Loop

public class Main {
    public static void main(String[] args) {
        int outer = 1;

        do {
            int inner = 1;

            do {
                System.out.println("Outer: " + outer + ", Inner: " + inner);
                inner++;
            } while (inner <= 2);

            outer++;
        } while (outer <= 3);
    }
}

Output:

Outer: 1, Inner: 1
Outer: 1, Inner: 2
Outer: 2, Inner: 1
Outer: 2, Inner: 2
Outer: 3, Inner: 1
Outer: 3, Inner: 2

In this example, the outer loop runs three times, and for each iteration of the outer loop, the inner loop runs twice.

8. Best Practices for Using do-while Loops

Use do-while when you need the code to run at least once: The do-while loop is useful when the condition check comes after the first execution, ensuring the block runs at least once.

Avoid infinite loops: Always ensure the condition in the while statement will eventually evaluate to false to avoid infinite loops.

Use break and continue wisely: While these keywords provide control over the loop, overusing them can make the code harder to follow.

Maintain readability: If a do-while loop becomes complex or deeply nested, consider refactoring your code to improve readability.

Conclusion

The do-while loop in Java is a powerful control structure that guarantees a block of code will run at least once.

This makes it useful in scenarios like input validation, menu-driven programs, and situations where the logic must be executed before the condition is checked.

Understanding how to effectively use do-while loops, along with break and continue statements, allows you to write more flexible and robust Java programs.

0 comment
0 FacebookTwitterPinterestEmail
Control Statements

Java while Loop: A Comprehensive Tutorial with Code Examples

written by 75ypsaw71

The while loop in Java is one of the most fundamental control flow statements. It repeatedly executes a block of code as long as a specified condition remains true.

This tutorial will walk you through the different ways to use the while loop with practical examples.

Table of Contents:

1. Introduction to while Loop

A while loop allows you to execute a block of code repeatedly based on a condition. As long as the condition evaluates to true, the code inside the loop is executed. If the condition becomes false, the loop terminates.

General Syntax:

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

condition: A boolean expression that is evaluated before each iteration.
If true: The loop executes the code block.
If false: The loop terminates.

2. Basic Syntax of while Loop

Example 1: Basic while Loop

public class Main {
    public static void main(String[] args) {
        int counter = 1;

        while (counter <= 5) {
            System.out.println("Counter: " + counter);
            counter++;
        }
    }
}

Output:

Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5

In this example:

The while loop continues running as long as counter <= 5.
The counter is incremented by 1 during each iteration, and the loop terminates when counter exceeds 5.

3. Simple Example of while Loop

Example 2: Summing Numbers with while Loop

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int number = 1;

        while (number <= 10) {
            sum += number;  // Add the current number to sum
            number++;
        }

        System.out.println("The sum of numbers from 1 to 10 is: " + sum);
    }
}

Output:

The sum of numbers from 1 to 10 is: 55

In this example, the loop runs until number reaches 10, adding each number to the sum variable.

4. Infinite Loops with while

An infinite loop occurs when the condition in the while statement never becomes false. This results in the loop running indefinitely unless interrupted by an external factor or a break statement.

Example 3: Infinite Loop

public class Main {
    public static void main(String[] args) {
        while (true) {
            System.out.println("This is an infinite loop.");
            // You can add a break statement to stop the loop if necessary.
            // break;
        }
    }
}

In this example, the condition true is always true, so the loop will run forever unless you manually stop the program or use a break statement.

5. Using break and continue in while Loop

break: Terminates the loop immediately.
continue: Skips the current iteration and continues with the next iteration.

Example 4: Using break in a while Loop

public class Main {
    public static void main(String[] args) {
        int count = 1;

        while (count <= 10) {
            if (count == 5) {
                break;  // Exit the loop when count is 5
            }
            System.out.println("Count: " + count);
            count++;
        }
    }
}

Output:

Count: 1
Count: 2
Count: 3
Count: 4

In this example, the loop is terminated using break when count equals 5.

Example 5: Using continue in a while Loop

public class Main {
    public static void main(String[] args) {
        int count = 0;

        while (count < 10) {
            count++;

            if (count % 2 == 0) {
                continue;  // Skip the rest of the loop for even numbers
            }

            System.out.println("Odd number: " + count);
        }
    }
}

Output:

Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9

In this example, continue is used to skip even numbers and only print odd numbers.

6. while Loop vs do-while Loop

While a while loop checks the condition before executing the loop, the do-while loop checks the condition after the code block is executed. This means that a do-while loop will always execute at least once, even if the condition is false.

Syntax of do-while Loop:

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

Example 6: do-while Loop

public class Main {
    public static void main(String[] args) {
        int count = 5;

        do {
            System.out.println("Count: " + count);
            count++;
        } while (count <= 3);
    }
}

Output:

Count: 5

In this case, the loop executes once because the do block runs before the condition is checked, even though count starts at 5, which is greater than 3.

7. Nested while Loops

You can nest while loops within other while loops, allowing you to handle multi-level iterations (e.g., working with 2D arrays).

Example 7: Nested while Loops

public class Main {
    public static void main(String[] args) {
        int outer = 1;

        while (outer <= 3) {
            int inner = 1;

            while (inner <= 2) {
                System.out.println("Outer: " + outer + ", Inner: " + inner);
                inner++;
            }

            outer++;
        }
    }
}

Output:

Outer: 1, Inner: 1
Outer: 1, Inner: 2
Outer: 2, Inner: 1
Outer: 2, Inner: 2
Outer: 3, Inner: 1
Outer: 3, Inner: 2

In this example, the outer loop runs 3 times, and for each iteration of the outer loop, the inner loop runs twice.

8. Best Practices for Using while Loops

Avoid infinite loops: Ensure that your condition will eventually evaluate to false. Without this, your loop will run forever, consuming system resources.

Use break cautiously: break can be used to terminate a loop early, but overusing it can make the code harder to follow. Ensure the logic is clear.

Keep track of loop variables: Make sure you modify the loop control variable (like counter++) inside the loop to avoid infinite loops.

Consider readability: If your loop’s logic becomes complex, consider refactoring it into smaller methods to improve readability.

9. Common Use Cases for while Loops

Example 8: User Input Validation with while

import java.util.Scanner;

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

        do {
            System.out.println("Enter a number between 1 and 10:");
            number = scanner.nextInt();
        } while (number < 1 || number > 10);

        System.out.println("You entered: " + number);
    }
}

Output (Example input: 11, then 6):

Enter a number between 1 and 10:
11
Enter a number between 1 and 10:
6
You entered: 6

This example ensures that the user provides a valid input (between 1 and 10) before proceeding.

Example 9: Simulating a Countdown

public class Main {
    public static void main(String[] args) {
        int countdown = 5;

        while (countdown > 0) {
            System.out.println("Countdown: " + countdown);
            countdown--;
        }

        System.out.println("Liftoff!");
    }
}

Output:

Countdown: 5
Countdown: 4
Countdown: 3
Countdown: 2
Countdown: 1
Liftoff!

This example simulates a simple countdown using a while loop.

Conclusion

The while loop is a powerful tool for repeating a block of code as long as a condition remains true.

Whether you're validating user input, summing numbers, or running complex logic, the while loop provides the flexibility needed to handle various use cases.

By understanding how to use break, continue, and nested loops, you can implement efficient and readable loops in your Java programs.

0 comment
0 FacebookTwitterPinterestEmail
Control Statements

Java if-else Statement: A Comprehensive Tutorial with Code Examples

written by 75ypsaw71

The if-else statement is one of the most basic and widely used control flow structures in Java. It allows the execution of different blocks of code based on whether a condition evaluates to true or false.

This tutorial will walk you through the various forms of the if-else statement, showing examples of how to use it in different scenarios.

Table of Contents:

1. What Is an if-else Statement?

An if-else statement is a control flow statement that allows you to conditionally execute a block of code based on whether a boolean expression evaluates to true or false.

General Syntax:

if (condition) {
    // Executes if the condition is true
} else {
    // Executes if the condition is false
}

condition: A boolean expression that is evaluated.
If true: The code inside the if block is executed.
If false: The code inside the else block (if present) is executed.

2. Basic if Statement

The simplest form of an if statement checks a condition and executes a block of code if the condition evaluates to true.

Example 1: Basic if Statement

public class Main {
    public static void main(String[] args) {
        int number = 10;

        // Check if the number is positive
        if (number > 0) {
            System.out.println("The number is positive.");
        }

        System.out.println("This statement always executes.");
    }
}

Output:

The number is positive.
This statement always executes.

Here, the condition number > 0 is true, so the if block is executed.

3. if-else Statement

An if-else statement is used when you need to execute one block of code if the condition is true and another block if the condition is false.

Example 2: if-else Statement

public class Main {
    public static void main(String[] args) {
        int number = -5;

        // Check if the number is positive or negative
        if (number > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Output:

The number is negative.

In this case, the condition number > 0 is false, so the else block is executed.

4. else if Ladder

When you have multiple conditions to check, you can use the else if ladder. This structure allows you to chain multiple conditions together.

Example 3: else if Ladder

public class Main {
    public static void main(String[] args) {
        int score = 85;

        // Check multiple conditions using else if
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
    }
}

Output:

Grade: B

Here, the else if ladder checks multiple conditions in sequence. Once a condition is true, the corresponding block is executed, and the rest of the conditions are skipped.

5. Nested if-else Statements

You can nest if-else statements inside other if-else statements to handle complex conditions.

Example 4: Nested if-else

public class Main {
    public static void main(String[] args) {
        int number = 15;

        // Nested if-else example
        if (number > 0) {
            if (number % 2 == 0) {
                System.out.println("The number is positive and even.");
            } else {
                System.out.println("The number is positive and odd.");
            }
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Output:

The number is positive and odd.

In this example, the first if checks if the number is positive, and the second (nested) if-else checks if the number is even or odd.

6. Ternary Operator (?:)

The ternary operator is a shorthand version of the if-else statement. It’s useful for simple conditional logic and assigning values based on a condition.

Syntax:

condition ? value_if_true : value_if_false;

Example 5: Ternary Operator

public class Main {
    public static void main(String[] args) {
        int number = 10;

        // Ternary operator for checking positivity
        String result = (number > 0) ? "Positive" : "Negative";
        System.out.println("The number is " + result);
    }
}

Output:

The number is Positive

The ternary operator allows you to evaluate number > 0 and assign either “Positive” or “Negative” to result.

7. Best Practices for if-else Statements

Avoid deep nesting: Deeply nested if-else blocks can make your code harder to read. Consider using methods to break complex logic into simpler parts.
Use else if instead of multiple if: When checking mutually exclusive conditions, prefer else if to avoid unnecessary evaluations.

Example 6: Avoid Unnecessary if

// Inefficient way:
if (x == 1) { ... }
if (x == 2) { ... }

// More efficient:
if (x == 1) { ... }
else if (x == 2) { ... }

Use the ternary operator for simple conditions: When you need to conditionally assign a value, the ternary operator can simplify your code.
Always handle all possible conditions: Always provide an else or else if block to handle cases where none of the conditions match.

8. Common Use Cases for if-else

Example 7: Checking User Input

import java.util.Scanner;

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

        System.out.println("Enter a number:");
        int number = scanner.nextInt();

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number < 0) {
            System.out.println("The number is negative.");
        } else {
            System.out.println("The number is zero.");
        }
    }
}

Output (Example input: 0):

The number is zero.

This example checks whether the user input is positive, negative, or zero.

Example 8: Age-Based Conditions

public class Main {
    public static void main(String[] args) {
        int age = 20;

        if (age >= 18) {
            System.out.println("You are an adult.");
        } else {
            System.out.println("You are a minor.");
        }
    }
}

Output:

You are an adult.

Here, the if condition checks if the person is legally an adult based on their age.

Conclusion

The if-else statement is one of the most fundamental control structures in Java, allowing you to execute code conditionally.

By understanding how to use if, if-else, else if, and the ternary operator, you can write clear and efficient conditional logic.

Whether you are performing basic checks, validating user input, or dealing with complex logic, the if-else statement provides the flexibility to handle various conditions in your programs.

0 comment
0 FacebookTwitterPinterestEmail
Control Statements

Java switch Statement: A Comprehensive Tutorial with Code Examples

written by 75ypsaw71

The switch statement in Java is a control flow structure that allows you to execute different parts of your code based on the value of a given variable. It is often used as an alternative to long chains of if-else statements, making the code more readable and easier to manage when multiple conditions are checked.

This tutorial will walk you through how the switch statement works in Java, along with several examples demonstrating its usage.

Table of Contents:

1. Introduction to switch Statement

The switch statement evaluates a variable and compares it against a list of predefined values (called case values). Based on which case matches, the corresponding block of code is executed. It is commonly used when you need to check multiple potential values for a single variable.

2. Syntax of switch Statement

Syntax:

switch (expression) {
    case value1:
        // Code to be executed when expression equals value1
        break;
    case value2:
        // Code to be executed when expression equals value2
        break;
    default:
        // Code to be executed if none of the above cases match
}

expression: The value being evaluated (must be a byte, short, char, int, String, or an enum).
case: Specifies possible values for expression.
break: Exits the switch block after a case is matched (prevents fall-through to other cases).
default: Optional block that runs if no case matches the expression.

3. How the switch Statement Works

The switch statement compares the expression with each case. If a match is found, the corresponding block of code is executed, and the break statement ensures that the program exits the switch block. If no case matches, the default block is executed, if provided.

Example 1: Basic switch Statement

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

Output:

Wednesday

In this example, the value of day is 3, which matches the third case, so “Wednesday” is printed.

4. Using break and default in switch

break: The break statement terminates the switch block once a matching case is executed. Without break, the program will continue to execute the subsequent cases, leading to fall-through.

Example 2: Fall-Through Without break

public class Main {
    public static void main(String[] args) {
        int day = 2;

        switch (day) {
            case 1:
                System.out.println("Monday");
            case 2:
                System.out.println("Tuesday");
            case 3:
                System.out.println("Wednesday");
            default:
                System.out.println("Invalid day");
        }
    }
}

Output:

Tuesday
Wednesday
Invalid day

Here, since there’s no break, the code “falls through” to the subsequent cases after matching day = 2, leading to unexpected output.

default: The default case runs when none of the case values match the expression.

Example 3: Using default Case

public class Main {
    public static void main(String[] args) {
        int day = 7;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

Output:

Invalid day

Here, the value of day doesn't match any of the cases, so the default case is executed.

5. Using switch with Strings (Java 7 and above)

Starting from Java 7, you can use switch with String values, which was not possible in earlier versions.

Example 4: switch with Strings

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";

        switch (fruit) {
            case "apple":
                System.out.println("Fruit is apple");
                break;
            case "banana":
                System.out.println("Fruit is banana");
                break;
            default:
                System.out.println("Unknown fruit");
        }
    }
}

Output:

Fruit is apple

In this example, the value of fruit is “apple”, which matches the first case.

6. Using switch with Enums

Enums are a good fit for the switch statement, as they represent a set of predefined constants. Using enums with switch can make your code more readable and robust.

Example 5: switch with Enums

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;

        switch (today) {
            case MONDAY:
                System.out.println("It's Monday");
                break;
            case WEDNESDAY:
                System.out.println("It's Wednesday");
                break;
            case FRIDAY:
                System.out.println("It's Friday");
                break;
            default:
                System.out.println("Not a special day");
        }
    }
}

Output:

It's Wednesday

Here, the enum Day is used in the switch statement, making it more readable when handling multiple constants.

7. Nested switch Statements

You can nest switch statements within each other, but it's generally advisable to avoid deep nesting for readability reasons.

Example 6: Nested switch Statement

public class Main {
    public static void main(String[] args) {
        int outerVar = 1;
        int innerVar = 2;

        switch (outerVar) {
            case 1:
                System.out.println("Outer: Case 1");

                switch (innerVar) {
                    case 2:
                        System.out.println("Inner: Case 2");
                        break;
                    case 3:
                        System.out.println("Inner: Case 3");
                        break;
                }
                break;
            case 2:
                System.out.println("Outer: Case 2");
                break;
        }
    }
}
Output:

Outer: Case 1
Inner: Case 2

This example demonstrates a nested switch structure where outerVar and innerVar control different layers of the decision-making.

8. Best Practices for Using switch

Use enums or constants: Enums and constants make your code more readable and prevent errors from using arbitrary values.
Avoid fall-through behavior: Ensure that each case block ends with a break unless you explicitly want fall-through behavior.
Use default for safety: Always include a default case to handle unexpected values, even if you don’t expect it to run.

9. Limitations of the switch Statement

Limited types: switch only supports int, byte, short, char, String, and enum. It doesn't support types like double, float, or boolean.
Duplicate cases: You cannot have duplicate case labels within the same switch statement. Doing so will cause a compilation error.

Conclusion

The switch statement in Java is a powerful control structure for handling multiple conditions based on a single variable. It provides a clear and concise way to deal with multiple possible values without using lengthy if-else chains.

By using switch with types like String and enums, you can write cleaner and more maintainable code.

Always be cautious with fall-through behavior and use the default case to handle unexpected values.

0 comment
0 FacebookTwitterPinterestEmail