while Loops
while Loops
- A while loop is a fundamental control structure in programming used for repeated execution of a block of code as long as a condition is true.
- The loop starts by evaluating the condition. If the condition is true, the code inside the loop is executed.
- After each iteration, the condition is re-evaluated, and if it’s still true, the loop continues. If the condition is false initially, the loop code is never executed.
- While loops are used when you don’t know in advance how many times the loop needs to execute.
- There’s a risk of infinite loops if the condition never becomes false, so be cautious. You can use variables and complex expressions as loop conditions.
- It’s essential to update the loop control variable within the loop to prevent infinite loops.
- While loops are typically used for tasks such as iterating over collections or waiting for a specific condition to be met.
- You can always break out of a while loop prematurely using the break statement.
Example of While Loops
public class PyramidPattern {
public static void main(String[] args) {
int height = 5;
int row = 1;
while (row <= height) {
int spaces = height - row;
int stars = 2 * row - 1;
// Print spaces
int spaceCount = spaces;
while (spaceCount > 0) {
System.out.print(" ");
spaceCount--;
}
// Print stars
int starCount = stars;
while (starCount > 0) {
System.out.print("*");
starCount--;
}
System.out.println(); // Move to the next line for the next row
row++;
}
}
}
PyramidPattern.main(null);
4.4 Nested Iteration
nested iteration
occurs when we have a loop inside of another loop, similar to nested conditional statements in unit 3
When you have one loop inside another, the inner loop has to finish all its rounds before the outer loop moves to the next round. If the inner loop has a "stop" command, it only stops for that round of the outer loop. The next time the outer loop starts a new round, the inner loop starts over.
If you have two nested loops without stops, and the outer one runs n times while the inner one runs m times each time the outer one goes around, the inner loop will run m times n times, which is m * n times in total. This rule also applies if you have more than two nested loops. To find the total number of times the innermost loop runs, just multiply how many times each loop runs per round.
```java
public class NestedLoopsDemo {
public static void main(String[] args) {
int n = 3; //numb of times the outside loop runs
int m = 2; //numb of times the inside loop runs
//the nested loops
for (int i = 1; i <= n; i++) {
System.out.println("Outer loop iteration: " + i);
for (int j = 1; j <= m; j++) {
System.out.println("Inner loop iteration: " + j);
}
}
}
}
NestedLoopsDemo.main(null)
```
```java
// CODE EXAMPLE #2 (for loop)
public class InformalCodeAnalysis {
public static void main(String[] args) {
int count = 0;
for (int k = 4; k < 30; k+=3)
{
count++; // statement 3
}
}
}
```
How many times will statement 3 execute?
Answer:
```java
// Rewrite the code segment below to have a faster run-time based on statement execution counts
for (int k = 0; k < 135; k++)
{
if (k % 5 == 0)
{
System.out.println(k);
}
}
```
```java
// CODE EXAMPLE #3 (while loop)
int num = (int)(Math.random() * 10);
while (num % 2 != 0)
{
num = (int)(Math.random() * 10) // statement 4
}
```
What is the min/max number of times statement 4 will execute?
Answer:
```java
// CODE EXAMPLE #4 (nested loop)
for (int outer = 0; outer < 3; outer++)
{
for (int inner = 0; inner < 4; inner++)
{
// statement #5
}
}
```