Laços Aninhados Java

Java, como a maioria das outras linguagens de programação, suporta loops aninhados. Isso significa apenas um loop dentro de um loop. Neste artigo, vamos descobrir como trabalhar com loops aninhados em Java.

Java loops aninhados

Um loop é chamado aninhado se for colocado dentro de outro loop. Na primeira passagem, o loop externo chama o loop interno, que é executado até a conclusão, após o que o controle é transferido para o corpo do loop externo. Na segunda passagem, o loop externo chama o interno novamente. E assim por diante até que o loop externo termine. Existem quatro tipos de loops em Java:

• para loop

• loop while

• fazer... loop while

• para cada loop

Todos eles suportam loops aninhados. As construções de loop aninhado são usadas quando duas condições devem ser atendidas, uma dependendo da outra. Por exemplo, se você precisar exibir uma matriz bidimensional, uma semipirâmide ou uma tabela de multiplicação.

Como os loops aninhados Java funcionam

Provavelmente o loop mais usado em Java é for , em grande parte porque é bastante versátil e o código com ele é bastante fácil de ler. Aqui está a sintaxe geral para loop for aninhado :

// outer loop
for (initialization; condition; increment) {
  //write here your code 

  //nested loop
  for(initialization; condition; increment) {
    //write here your code
  }
..
}

Como ele funciona? O loop externo é iniciado. Em seguida, o loop for aninhado inicia o trabalho e percorre seu índice até que a condição seja atendida e, novamente, passa o trabalho para o loop externo, e isso acontece até que a condição do loop externo seja atendida. Soa um pouco complicado, não é? Bem, será muito mais fácil entender com um exemplo específico, então vamos a ele.

Exemplo de código de loop for aninhado

Aqui está um exemplo clássico. Vamos imprimir uma meia pirâmide usando dois loops for . Um deles está aninhado.

public class NestedLoopsDemo1 {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           for (int j = 0; j<=i;  j++)
               System.out.print("*");
           System.out.println();
       }
      
   }
}

A saída é:

Exemplo de código de loop while aninhado

public class NestedLoopsDemo2 {

   public static void main(String[] args) {

       int i = 0;
       while (i < 10) {
           int j = 0;
           while (j <= i) {
               System.out.print("*");
               j++;
           }
           System.out.println();
           i++;

       }
   }
}

A saída é a mesma do exemplo anterior: O loop do...while é semelhante ao loop while . A principal diferença é que o corpo do loop do...while é executado uma vez antes da verificação da expressão.

Exemplo de código de loops foreach aninhados

O loop for-each pode ser aninhado como o loop for usual . Aqui está o exemplo para loop for-each aninhado que itera array bidimensional.

public class NestedLoops2 {

       public static void main(String[] args)
       {
           int[][] mainArray = { {5, 4, 3, 2, 1}, {7, 8, 9, 10, 11} };

           for (int[] myArray : mainArray)
           {
               for (int i : myArray)
               {
                   System.out.print(i+" ");
               }
               System.out.println("");
           }
       }
}

A saída é:

Exemplo de loop for e while misto

Às vezes, podemos aninhar diferentes tipos de loops uns dentro dos outros. Por exemplo, for inside while ou for inside for-each . No entanto, não é a melhor prática de programação. Tais construções prejudicam significativamente a legibilidade do código. Portanto, os programadores profissionais tentam não misturar um com o outro. Bem, eles fazem, mas apenas se for realmente necessário. E mais uma pequena regra: se você está escolhendo entre while e for , use for sempre que possível. No entanto, aqui teremos um exemplo de uso de um loop for dentro do while . Vamos construir nossa semi-pirâmide novamente.

public class NestedLoopsDemo2 {

   public static void main(String[] args) {
       int i = 0;
       while (i < 10) {
           for (int j = 0; j <= i; j++) {
               System.out.print("*");
           }
           System.out.println();
           i++;

       }
   }
}

A saída é sem surpresas: