Јава Вхиле Лооп



Јава

Јава вхиле петља је још једна наредба за контролу петље која извршава скуп наредби на основу датог услова. У овом упутству ћемо детаљно размотрити јава вхиле лооп. У поређењу са за петљу, док петља нема ниједан фиксни број итерација. за разлику од for лооп, опсег променљиве која се користи у јава вхиле лооп није ограничен унутар петље, јер променљиву декларишемо изван петље.

Синтакса Јава вхиле лооп-а

while(test_expression) {
  //code
  update_counter;//update the variable value used in the test_expression
}

тест_екпрессион - Ово је услов или израз на основу којег се извршава вхиле петља. Ако је услов тачан, извршава код унутар вхиле петље. Ако је нетачно, излази из вхиле петље.

упдате_цоунтер - Ово је за ажурирање вредности променљиве која се користи у стању јава вхиле петље. Ако ово не одредимо, могло би доћи до бесконачне петље.

Како вхиле петља ради

Доња шема приказује вам како функционише Јава while петља ради.

Јава вхиле петља

 

  • Када контрола извршења упути на наредбу вхиле, прво процењује стање или тест израз. Услов може бити било који оператор.
  • Ако се услов врати а прави валуе, извршава код унутар вхиле петље.
  • То је онда Ажурирање вредност променљиве или повећава или смањује променљиву. Важно је укључити овај код унутар петље јава вхиле, у супротном може доћи до бесконачне петље јава вхиле. Разговараћемо о бесконачној петљи пред крај упутства.
  • Опет контрола показује на изјаву вхиле и понавља горње кораке.
  • Када се услов врати а лажан вредност излази из петље јава вхиле и наставља са извршавањем наредби изван вхиле петље

Пример једноставног јава вхиле лооп-а

Испод је једноставан код који демонстрира јава вхиле петљу.

public class simpleWhileLoopDemo {

  public static void main(String[] args) {
    int i=1;
    while(i<=5) {
      System.out.println("Value of i is: " + i);
      i++;
    }

  }

}
Value of i is: 1
Value of i is: 2
Value of i is: 3
Value of i is: 4
Value of i is: 5

Прво декларишемо променљиву инт i и иницијализујемо са вредношћу 1. У стању вхиле имамо израз као и <= 5, што значи до i вредност је мања или једнака 5, извршава петљу.

Отуда у 1. итерацији, када и = КСНУМКС, услов је тачан и исписује изјаву унутар јава вхиле петље. Затим се повећава i вредност за 1 што значи сада и = КСНУМКС.

Затим поново проверава да ли и <= 5. С обзиром да је тачно, поново извршава код унутар петље и повећава вредност.

Понавља горње кораке до и = КСНУМКС. У овој фази, након извршавања кода унутар вхиле петље, i прираштаји вредности и и = КСНУМКС. Сада услов враћа фалсе и тиме излази из јава вхиле петље.

Петља вхиле у низу

Слично for петљу, такође можемо користити петљу Јава за преузимање елемената низа. У доњем примеру дохваћамо елементе низа и проналазимо збир свих бројева помоћу вхиле петље.

public class whileLoopArray {

  public static void main(String[] args) {
    int[] numbers = {20,10,40,50,30};
    int i=0;
    int sum=0;
    while(i<numbers.length) {
      sum = sum+numbers[i];
      i=i+1;
    }
    System.out.println("Sum of array elements: " + sum);
    System.out.println("Length of array: " + i);
  }

}
Sum of array elements: 150
Length of array: 5

objašnjenje:

Прво, иницијализујемо низ целих бројева бројеви и прогласите бројач јава вхиле петље варијабла i. С обзиром да је реч о низу, потребно је да прелазимо кроз све елементе у низу до последњег елемента. За ово користимо дужину метод унутар јаве вхиле петље. То значи да се петља вхиле извршава до i вредност достиже дужину низа.

Понављање 1 када је и = 0: услов: тачно, збир = 20, и = 1

Понављање 2 када је и = 1: услов: тачно, збир = 30, и = 2

Понављање 3 када је и = 2: услов: тачно, збир = 70, и = 3

Понављање 4 када је и = 3: услов: тачно, збир = 120, и = 4

Понављање 5 када је и = 4: услов: тачно, збир = 150, и = 5

Понављање 6 када је и = 5: услов: нетачно -> излази while петља

Молимо погледајте наш Низови у јави водич да бисте сазнали више о низовима.

Бесконачна петља

Као што је речено на почетку водича, када променљиву бројача не ажурирамо правилно или не условимо правилно, резултат ће бити бесконачан while петља. Погледајмо ово на примеру испод.

public class infiniteWhileLoop {

  public static void main(String[] args) {
    int i = 0;
    while(i>=0) {
      System.out.println(i);
      i++;
    }

  }

}

Овде смо иницијализовали променљиву са вредношћу 0. У стању петље јава вхиле проверавамо да ли i вредност је већа или једнака 0. Пошто се увећавамо i вредност унутар вхиле петље, услов и> = 0 док увек враћа а прави вредност и извршиће бесконачно.

Такође можемо имати бесконачну петљу Јава док на други начин, као што можете видети у доњем примеру. Овде је вредност променљиве бФлаг је увек тачно, јер не ажурирамо вредност променљиве.

public class infiniteWhileLoop {

  public static void main(String[] args) {
    Boolean bFlag = true;
    while(bFlag) {
      System.out.println("Infinite loop");
    }

  }

}

Отуда се бесконачна јава вхиле петља јавља у испод 2 услова. Увек је важно запамтити ове две тачке када користите вхиле петљу.

  • када не ажурирамо вредност променљиве
  • када не користимо правилно услов у вхиле петљи

Угњежђена вхиле петља

Такође можемо имати угнежђену петљу вхиле у јави сличну for петља. Када има више вхиле петљи, називамо је угнежденом вхиле петљом.

public class Nestedwhileloop {

  public static void main(String[] args) {
    int i=1,j=10;
    while(i<=5) {
      System.out.println("i: " + i);
      i++;
      while(j>=5) {
        System.out.println("j: " + j);
        j--;
      }
    }

  }

}
i: 1
j: 10
j: 9
j: 8
j: 7
j: 6
j: 5
i: 2
i: 3
i: 4
i: 5

У овом примеру имамо 2 вхиле петље. Спољна вхиле петља понавља до и <= 5 а унутрашња вхиле петља понавља до ј> = 5.

Када и = КСНУМКС, услов је тачан и штампа i вредност, а затим увећава i вредност за 1. Затим извршава унутрашњу вхиле петљу са вредношћу ј = 10. Пошто је услов ј> = 5 је тачно, исписује ј вредност. Сада наставља извршење унутрашње вхиле петље у потпуности до услова ј> = 5 враћа фалсе. Једном када је лажно, наставља се са спољним извршавањем петље вхиле и <= 5 враћа фалсе.

Због тога на излазу можете видети након штампања и = КСНУМКС, извршава све j вредности почев од ј = 10 до ј = 5 а затим отисци i вредности до и = КСНУМКС. Када и = КСНУМКС, не извршава унутрашње while петља јер је услов нетачан.

Јава вхиле петља са више услова

Можемо имати више услова са више променљивих унутар јава вхиле петље. У доњем примеру имамо 2 променљиве a i иницијализовано вредностима 0. Овде ћемо исписати парне бројеве између 0 и 20. За то, унутар петље Јава док имамо услов а <= 10, што је само променљива бројача и још један услов ((и% 2) == 0) да провери да ли је паран број. Унутар петље Јава, повећавамо променљиву бројача a од 1 и i вредност за 2.

public class Whileloopconditions {

  public static void main(String[] args) {
    int a = 0;
    int i = 0;
    System.out.println("Even numbers between 0 to 20:");
    while((a<=10) && ((i%2)==0)) {
      System.out.println(i);
      a++;
      i=i+2;
    }
  }

}
Even numbers between 0 to 20:
0
2
4
6
8
10
12
14
16
18
20

Препорука