while and do while in Java

A ComprehensiveGuide to `while` and `do-while` Statements

Introduction:

In the world of programming, loops play a crucial role in executing repetitive tasks efficiently. Java, being one of the most widely used programming languages, offers two main types of loops: `while` and `do-while`. In this blog post, we will explore the fundamentals of these loop structures, their differences, use cases, and best practices.

## The `while` Loop:

### Syntax:

```java

while (condition) {

// Code to be executed while the condition is true

}

```

### Working Principle:

The `while` loop in Java repeatedly executes a block of code as long as the specified condition evaluates to true. It is essential to ensure that the condition eventually becomes false; otherwise, the loop will run indefinitely, resulting in an infinite loop.

### Example:

```java

int count = 1;

while (count <= 5) {

System.out.println("Count is: " + count);

count++;

}

```

In this example, the loop will iterate five times, printing the value of `count` from 1 to 5.

## The `do-while` Loop:

### Syntax:

```java

do {

// Code to be executed

} while (condition);

```

### Working Principle:

The `do-while` loop is similar to the `while` loop, with one key difference: the code block is executed at least once before checking the condition. This guarantees that the loop runs at least once, regardless of the initial condition's truth value.

### Example:

```java

int num = 5;

do {

System.out.println("Number is: " + num);

num--;

} while (num > 0);

```

Here, the loop will print the value of `num` from 5 to 1.

## Key Differences:

1. **Execution Control:**

- In a `while` loop, the condition is checked before the execution of the code block.

- In a `do-while` loop, the code block is executed first, and then the condition is checked.

2. **Minimum Execution:**

- A `while` loop may not execute at all if the initial condition is false.

- A `do-while` loop guarantees at least one execution.

## Best Practices:

1. **Initialization and Updating:**

- Ensure proper initialization of loop variables.

- Update loop variables inside the loop to prevent infinite loops.

2. **Loop Conditions:**

- Design meaningful and clear conditions.

- Avoid complex conditions to enhance readability.

3. **Code Clarity:**

- Keep the code inside the loop concise and focused.

- Use indentation for better readability.

4. **Infinite Loop Handling:**

- Be cautious to avoid unintentional infinite loops.

- Use break or continue statements when appropriate.

## Conclusion:

Mastering the `while` and `do-while` loops in Java is essential for writing efficient and error-free code. Understanding the differences and applying best practices ensures that loops contribute to code readability, maintainability, and performance. By incorporating these loop structures into your Java programming repertoire, you empower yourself to tackle a wide range of tasks with elegance and precision.

Here are five simple examples of while loops in Java:

1. **Counting from 1 to 5:**

```java

int i = 1;

while (i <= 5) {

System.out.println(i);

i++;

}

```

2. **Printing even numbers up to 10:**

```java

int num = 2;

while (num <= 10) {

System.out.println(num);

num += 2;

}

```

3. **User input validation for positive number:**

```java

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

int userInput;

System.out.print("Enter a positive number: ");

userInput = scanner.nextInt();

while (userInput <= 0) {

System.out.print("Please enter a positive number: ");

userInput = scanner.nextInt();

}

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

```

4. **Summing numbers up to a given limit:**

```java

int limit = 5;

int sum = 0;

int counter = 1;

while (counter <= limit) {

sum += counter;

counter++;

}

System.out.println("Sum of numbers from 1 to " + limit + ": " + sum);

```

5. **Reversing a string:**

```java

String original = "Hello";

int length = original.length();

String reversed = "";

int index = length - 1;

while (index >= 0) {

reversed += original.charAt(index);

index--;

}

System.out.println("Reversed string: " + reversed);

```

Here are the same examples implemented using `do-while` loops in Java:

1. **Counting from 1 to 5:**

```java

int i = 1;

do {

System.out.println(i);

i++;

} while (i <= 5);

```

2. **Printing even numbers up to 10:**

```java

int num = 2;

do {

System.out.println(num);

num += 2;

} while (num <= 10);

```

3. **User input validation for positive number:**

```java

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

int userInput;

do {

System.out.print("Enter a positive number: ");

userInput = scanner.nextInt();

} while (userInput <= 0);

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

```

4. **Summing numbers up to a given limit:**

```java

int limit = 5;

int sum = 0;

int counter = 1;

do {

sum += counter;

counter++;

} while (counter <= limit);

System.out.println("Sum of numbers from 1 to " + limit + ": " + sum);

```

5. **Reversing a string:**

```java

String original = "Hello";

int length = original.length();

String reversed = "";

int index = length - 1;

do {

reversed += original.charAt(index);

index--;

} while (index >= 0);

System.out.println("Reversed string: " + reversed);

```

These examples demonstrate the use of `do-while` loops for various scenarios. The key difference is that `do-while` guarantees the execution of the loop body at least once before checking the loop condition.