Os loops na programação permitem que um conjunto de instruções seja executado várias vezes com base em uma condição. Em Java existem três tipos de Loops que são explicados abaixo:

1. para loop

O loop for é usado quando sabemos o número de iterações (sabemos quantas vezes queremos repetir uma tarefa). A instrução for inclui a condição de inicialização e incremento/decremento em uma linha. 

Exemplo: O programa Java abaixo demonstra um loop for que imprime números de 0 a 10 em uma única linha.

// Java program to demonstrates the working of for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 10; i++) {  System.out.print(i + ' ');  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxe:

for (inicialização; condição; incremento/decremento) {

//código a ser executado

}

A imagem abaixo demonstra o fluxograma de um loop for:

• Condição de inicialização : Aqui inicializamos a variável em uso. Ele marca o início de um loop for. Uma variável já declarada pode ser usada ou uma variável pode ser declarada local apenas para loop.
• Condição de teste: É usado para testar a condição de saída de um loop. Deve retornar um valor booleano. É também um Loop de Controle de Entrada, pois a condição é verificada antes da execução das instruções do loop.
• Execução de declaração : Depois que a condição é avaliada como verdadeira, as instruções no corpo do loop são executadas.
• Incremento/Decremento : É usado para atualizar a variável para a próxima iteração.
• Terminação de loop :Quando a condição se torna falsa, o loop termina marcando o fim do seu ciclo de vida.

Observação : Existe outra forma de loop for conhecida como Aprimorado para loop ou (para cada loop).

inserir marca d'água no word

Loop for aprimorado (para cada)

Este loop é usado para iterar matrizes ou coleções.

Exemplo : O programa Java abaixo demonstra um loop for aprimorado (para cada loop) para iterar por meio de uma matriz e imprimir nomes.

// Java program to demonstrate  // the working of for each loop import java.io.*; class Geeks {  public static void main(String[] args)  {  String[] names = { 'Sweta' 'Gudly' 'Amiya' };  for (String name : names) {  System.out.println('Name: ' + name);  }  } } 

Name: Sweta Name: Gudly Name: Amiya 

Sintaxe:

for (variável dataType: arrayOrCollection) {

//código a ser executado

}

2. enquanto Loop

Um loop while é usado quando queremos verificar a condição antes de executar o corpo do loop.

Exemplo: O programa Java abaixo demonstra um loop while que imprime números de 0 a 10 em uma única linha.

// Java program to demonstrates  // the working of while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  while (i <= 10) {  System.out.print(i + ' ');  i++;  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxe:

enquanto (condição) {

//código a ser executado

}

A imagem abaixo demonstra o fluxograma de um loop while:

caso de mudança java

• O loop While começa com a verificação da condição booleana. Se for avaliado como verdadeiro, as instruções do corpo do loop serão executadas, caso contrário, a primeira instrução após o loop será executada. Por esta razão também é chamado de malha de controle de entrada
• Depois que a condição é avaliada como verdadeira, as instruções no corpo do loop são executadas. Normalmente as instruções contêm um valor de atualização para a variável que está sendo processada na próxima iteração.
• Quando a condição se torna falsa, o loop termina, o que marca o fim do seu ciclo de vida.

3. Loop do-while

O loop do-while garante que o bloco de código seja executado pelo menos uma vez antes de verificar a condição.

Exemplo : O programa Java abaixo demonstra um loop do-while que imprime números de 0 a 10 em uma única linha.

// Java program to demonstrates  // the working of do-while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  do {  System.out.print(i + ' ');  i++;  } while (i <= 10);  } } 

0 1 2 3 4 5 6 7 8 9 10 

Sintaxe:

fazer {

//código a ser executado

} while (condição);

A imagem abaixo demonstra o fluxograma de um loop do-while:

• do while loop começa com a execução da instrução. Não há verificação de nenhuma condição pela primeira vez.
• Após a execução das instruções e atualização do valor da variável a condição é verificada quanto ao valor verdadeiro ou falso. Se for avaliado como verdadeiro, a próxima iteração do loop será iniciada.
• Quando a condição se torna falsa, o loop termina, o que marca o fim do seu ciclo de vida.
• É importante observar que o loop do-while executará suas instruções pelo menos uma vez antes de qualquer condição ser verificada e, portanto, é um exemplo de loop de controle de saída.

Erros comuns de loop e como evitá-los

Se os loops não forem usados ​​corretamente, eles podem introduzir armadilhas e bugs que afetam a legibilidade e a funcionalidade do desempenho do código. Abaixo estão algumas armadilhas comuns de loops:

1. Loops infinitos

Este é um dos erros mais comuns ao implementar qualquer tipo de loop: ele pode nunca sair, ou seja, o loop é executado por tempo infinito. Isso acontece quando a condição falha por algum motivo.

Tipos de Loops Infinitos:

• infinito para Loop
• infinito enquanto Loop

Exemplo: Aqui ambos os exemplos demonstram os loops infinitos.

classificação de pilha

// Java program to demonstrate  // the infinite for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i--) {  System.out.println(  'This loop will run forever');  }  } } 

// Java Program to demonstrate  // the infinite while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  while(true)  {  System.out.println(  'Basic example of infinte loop');  }  } } 

Saída: Ao executar os dois códigos acima, você receberá um erro TLE (Time Limit Exceeded).

2. Erros ocasionais

Erros Off-by-One são causados ​​quando o loop é executado mais ou menos vezes do que o desejado. Basicamente acontece quando a condição do loop não está definida corretamente.

Exemplo : O programa Java abaixo demonstra um erro off-by-one em que o loop é executado 6 vezes e esperávamos que fosse executado 5 vezes.

// Java Program to demonstrates Off-by-One Errors import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 5; i++) {  System.out.print(i + ' ');  }  } } 

3. Modificando variáveis ​​de loop dentro do loop

Quando alteramos a condição do loop (como i) dentro do loop, isso pode fazer com que o loop pule certas iterações ou se comporte de maneiras que não esperávamos. Isso pode levar a erros ou comportamento inesperado.

Exemplo : O programa Java abaixo demonstra a modificação da variável de loop dentro do loop, o que faz com que o loop pule certas iterações e se comporte de forma inesperada.

// Java program demonstrates  // modification in i variable import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i++) {  if (i == 2) {    // Modifies the loop variable and skips  // the next iteration  i++;  }  System.out.println(i);  }  } } 

4. Corpo do Loop Vazio

Um corpo de loop vazio ocorre quando um loop é escrito para iterar, mas não executa nenhuma operação dentro do loop. Executar um loop sem nenhuma operação útil dentro dele pode ser confuso.

Exemplo: O programa Java abaixo demonstra o corpo do loop vazio.

// Java program to demonstrates Empty loop body import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 10; i++) {    // Empty body no operations  }  } } 

Nenhuma saída será gerada para isso porque o corpo do loop está vazio.

Tabela Resumo

Postagens relacionadas:

• para loop
• enquanto loop
• loop do-while