Java while loops have the simplest syntax. Think back to the if statements for a moment. We could put virtually any combination of operators and variables in the conditional expression of the if statement. If the expression evaluated to true then the code in the body of the if block is executed. With the while loop we also put an expression that can evaluate to true or false. Take a look at this code:

int x = 10;

while(x > 0){
  x--;
  // x decreases by one each pass through the loop
}

What happens here is this: outside of the while loop an int named x is declared and initialized to 10. Then, the while loop begins. Its condition is x > 0. So, the while loop will continue looping through the code in its body until the condition evaluates to false. So the previous code will execute 10 times.

On the first pass x = 10 then 9 then 8, and so on. But once x is equal to 0, it is of course no longer greater than 0, the program will exit the loop and continue with the first line of code after the while loop.

Just like an if statement, it is possible that the while loop will not execute even once. Take a look at this:

int x = 10;

while(x > 10){
  // more code here.
  // but it will never run unless x is greater than 10.
}

Moreover, there is no limit to the complexity of the conditional expression or the amount of code that can go into the loop body:

int newMessages = 3;
int unreadMessages = 0;

while(newMessages > 0 || unreadMessages > 0){
  // Display next message
  // etc.
}

// continue here when newMessages and unreadMessages equal 0

The previous while loop would continue to execute until both newMessages and unreadMessages were equal to or less than zero. As the condition uses logical OR operator || either one of those conditions being true will cause the while loop to continue executing.

It is worth noting that once the body of the loop has been entered, it will always complete, even if the expression evaluates to false part way through, as it is not tested again until the code tries to start another pass. For example:

int x = 1;

while(x > 0){
  x--;
  // x is now 0 so the condition is false
  // But this line still runs
  // and this one
  // and me!

}

The previous loop body will execute exactly once. We can also set a while loop that will run forever; unsurprisingly called an infinite loop. Here is one:

int x = 0;

while(true){
  x++; // I am going to get mighty big!
}

int x = 0;

while(true){
  x++; //I am going to get mighty big!
  break; // No you're not haha.
  // code doesn't reach here
}

int x = 0;
int tooBig = 10;

while(true){
  x++; // I am going to get mighty big!
  if(x == tooBig){
    break;
  } // No you're not haha.
  
  // code reaches here only until x = 10
}

int x = 0;
int tooBig = 10;
int tooBigToPrint = 5;

while(true){
  x++; // I am going to get mighty big!
  if(x == tooBig){
    break;
  } // No you're not haha.
  
  // code reaches here only until x = 10

  if(x >= tooBigToPrint){
    // No more printing but keep looping
    continue;
  }
  // code reaches here only until x = 5

  // Print out x 

}

A do while loop is very much the same as a while loop with the exception that a do while loop evaluates its expression after the body. This means that a do while loop will always execute at least once before checking the loop condition:

int x= 0
do{
  x++;
}while(x < 10);
// x now = 10 

A for loop has a slightly more complicated syntax than while or do while loops as it takes three parts to initialize. Have a look at the code first then we will break it apart:

for(int i = 0; i < 10;  i++){

  //Something that needs to happen 10 times goes here

}

The apparently obscure form of the for loop is clearer when put like this:

for(declaration and initialization; condition; change after each pass through loop)

To clarify further we have:

The for loop essentially takes control of initialization, condition evaluation, and the control variable itself.

To get started, create a new Android project called Loops, use a Blank Activity, and leave all the other settings at their default.

Let's add a few buttons to our UI to make this more fun:

Looks are not important for this demo but the layout should look something like this next screenshot:

What is important is that we have three buttons labeled COUNTUP, COUNTDOWN, and NESTED, which call methods named countUp, countDown, and nested.

Switch to the MainActivity.java file by left-clicking the MainActivity.java tab above the editor and we can start coding our methods.

After the closing curly brace of the onCreate method, add the countUp method as shown next:

public void countUp(View v){
  Log.i("message:","In countUp method");
        
  int x = 0;

  // Now an apparently infinite while loop
  while(true){

       // Add 1 to x each time
       x++;
       Log.i("x =", "" + x);

       if(x == 3){
         // Get me out of here
         break;
       }
  }
}

We will be able to call this method we have just written, from the appropriately labeled button.

After the closing curly brace of the countUp method, add the countDown method:

public void countDown(View v){
  Log.i("message:","In countDown method");
  int x = 4;
  // Now an apparently infinite while loop
  while(true){
    // Add 1 to x each time
    x--;
    Log.i("x =", "" + x);
    if(x == 1){
      // Get me out of here
      break;
    }
  }
}

We will be able to call this method we have just written, from the appropriately labeled button.

After the closing curly brace of the countDown method, add the nested method:

public void nested(View v){
  Log.i("message:","In nested method");

  // a nested for loop
  for(int i = 0; i < 3; i ++){

    for(int j = 3; j > 0; j --){

      // Output the values of i and j
      Log.i("i =" + i,"j=" + j);
    }
  }
}

We will be able to call this method we have just written, from the appropriately labeled button.

Now, let's run the app and start tapping buttons. If you tap each of the buttons once from top to bottom, this is the console output you will see:

message:﹕ In countUp method
x =﹕ 1
x =﹕ 2
x =﹕ 3
message:﹕ In countDown method
x =﹕ 3
x =﹕ 2
x =﹕ 1
message:﹕ In nested method
i =0﹕ j=3
i =0﹕ j=2
i =0﹕ j=1
i =1﹕ j=3
i =1﹕ j=2
i =1﹕ j=1
i =2﹕ j=3
i =2﹕ j=2
i =2﹕ j=1

We can see that the countUp method does exactly that. The int x variable is initialized to zero, an infinite while loop is entered, and x is incremented with the increment ++ operator. Fortunately, on each iteration of the loop, we test for x being equal to 3 with if (x == 3) and break when this is true.

Next, in the countDown method, we do the same in reverse. The int x variable is initialized to 4, an infinite while loop is entered, and x is decremented with the decrement -- operator. This time, on each iteration of the loop, we test for x being equal to 1 with if (x == 1) and break when this is true.

Finally, we nest two for loops within each other. We can see from the output that for each time i (which is controlled by the outer loop) is incremented, j (which is controlled by the inner loop) is decremented from 3 to 1. Look carefully at this image that shows where the start and end of each for loop is, to help fully understand this:

You can of course keep tapping to observe each button's output for as long as you like. As an experiment, try making the loops longer, perhaps 1,000.