# Unit 4
## 4.1 While Loops
**Goals**
- Represent iterative processes using while loops.
- Use Boolean expressions to determine if a loop body is executed and when the iteration should cease.
- Write a program code to satisfy method specifications using expressions, conditional statements, and iterative statements.
In programming, loops are used to repeat a block of code `x` amount of times. With some loop programs, the expression is evaluated *(Is the condition true or not?)* before each iteration of the loop body. When the expression evaluates to `true`, the loop body is executed. This continues until the expression evaluates to false, where the loop ends.
**Note:** While Java is flexible with spacing around conditional expressions, between keywords, before and after operators, it is not however flexible with *spacing around the dot operator*. The following statements are not equivalent.
```java
str.substring(i, i+1);
str. substring(i, i+1); // syntax error
str .substring(i, i+1); // syntax error
```
One more thing, An **infinite loop** is an instruction sequence that loops endlessly when a terminating condition isn't met. An infinite loop might be a programming error, but may also be intentional.
Within Unit 4, we will explore different keyword loop terms and how they are utilized.
Take a look at the program below:
```java
public class Main {
public static void main(String[] args) {
int i=1;
while(i<=10){ // use of a Boolean to create a loop
System.out.println(i);
i++;
}
}
}
```
Another example using the `while` loop.
```java
public class Main {
public static void main(String[] args) {
int i = 1;
int n = 10; // use of a second variable to create a loop
while(i <= n) {
System.out.println(i);
i++;
}
}
}
```
Using `.equals` within a `while` loop.
```java
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter your input (q to quit): ");
String input = sc.nextLine();
while (!input.equals("q")) // use of a while loop using .equals
{
System.out.println("Enter your input (q to quit): ");
input = sc.nextLine();
}
System.out.println("Goodbye.");
}
}
```
Click Here
```java
import java.util.*;
public class Main{
public static void main(String[] args)
{
int i=0;
int n;
Scanner sc=new Scanner(System.in);
System.out.print("Enter the number of elements you want to store: ");
n = sc.nextInt(); // storing the number of elements that you want to store.
int[] array = new int[n]; // defining the number of inputs for the array
System.out.println("Enter the elements of the array: ");
while (i < n){
//reading array elements from the user
array[i] = sc.nextInt();
i++;
}
System.out.println("Contents of the array are: " + Arrays.toString(array));
// printing the stored elements within the array.
}
}
```
Click Here
```java
import java.util.Scanner;
public class Name {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int randomNumber = (int) (Math.random() * 100) + 1;
int userGuess;
System.out.println("Welcome to the Number Guessing Game!");
System.out.println("I've picked a number between 1 and 100. Try to guess it!");
do {
System.out.print("Enter your guess: ");
userGuess = scanner.nextInt();
if (userGuess == randomNumber) {
System.out.println("Congratulations! You guessed the correct number: " + randomNumber);
break;
} else {
int difference = Math.abs(randomNumber - userGuess);
if (difference <= 10) {
System.out.println("You're very close! Try again.");
} else if (difference <= 20) {
System.out.println("You're close! Try again.");
} else if (difference <= 30) {
System.out.println("You're getting warmer! Try again.");
} else {
System.out.println("You're far away! Try again.");
}
}
} while (true);
scanner.close();
}
}
```
--> Click Here
An **off-by-one error** occurs when a loop iterates one time too many or one time too few due to incorrect initialization, termination, or increment/decrement logic. This is a common logical error in programming.
**Example of an Off-by-One Error**
Consider a scenario where you want to iterate through an array of integers and print each element.
**Incorrect Code (with an Off-by-One Error)**
```java
public class Main {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
// Off-by-one error in loop condition
for (int i = 0; i <= numbers.length; i++) {
System.out.println(numbers[i]);
}
}
}
```
**Rationale:**
1. **Initialization (`int i = 0`)**: Correct, starts at the first index of the array.
2. **Condition (`i <= numbers.length`)**: Incorrect, as `numbers.length` is **5**, but the last valid index of the array is **4** (0-based indexing).
3. **Result**: The loop runs one extra iteration (when `i == 5`), causing an **ArrayIndexOutOfBoundsException**.
----------------------------------------------------------------
**Correct Code (Fixing the Error)**
```java
public class Main {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
// Correct loop condition
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
}
}
```
**Fix:**
- The loop condition is updated to `i < numbers.length` to ensure that the loop stops before `i` reaches `numbers.length`.
----------------------------------------------------------------
**Common Scenarios of Off-by-One Errors**
1. **Iterating through arrays**:
- Mistaking `<=` for `<` in the loop condition.
2. **Using ranges in loops**:
```java
for (int i = 1; i <= 10; i++) // Correct (includes 1 through 10)
for (int i = 1; i < 10; i++) // Correct (includes 1 through 9)
```
Accidentally swapping the two could lead to unintended behavior.
3. **String indexing**:
When processing a string character by character, forgetting that string indices start at `0` can cause off-by-one errors.