જાવા જ્યારે લૂપ



જાવા

જાવા જ્યારે લૂપ એ અન્ય લૂપ કંટ્રોલ સ્ટેટમેંટ છે જે આપેલ શરતના આધારે નિવેદનોનો સમૂહ ચલાવે છે. આ ટ્યુટોરીયલમાં, આપણે જાવા જ્યારે લૂપ વિશે વિગતવાર ચર્ચા કરીશું. જ્યારે તેની તુલના કરવામાં આવે છે લૂપ માટે, જ્યારે લૂપમાં પુનરાવૃત્તિની કોઈ નિશ્ચિત સંખ્યા નથી. વિપરીત for લૂપ, જાવામાં વપરાયેલ વેરીએબલનો અવકાશ જ્યારે લૂપની અંદર મર્યાદિત નથી, કારણ કે આપણે લૂપની બહાર વેરીએબલ જાહેર કરીએ છીએ.

જાવા જ્યારે લૂપ સિન્ટેક્સ

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

પરીક્ષણ_અથવા - આ તે સ્થિતિ અથવા અભિવ્યક્તિ છે જેના આધારે જ્યારે લૂપ ચલાવે છે. જો સ્થિતિ સાચી છે, તો તે જ્યારે લૂપની અંદર કોડ ચલાવે છે. જો તે ખોટું છે, તો તે જ્યારે લૂપમાંથી બહાર નીકળી જશે.

અપડેટ_કounન્ટર - આ વેરિયેબલ વેલ્યુને અપડેટ કરવા માટે છે જેનો ઉપયોગ જાવાની સ્થિતિમાં જ્યારે લૂપ દરમિયાન થાય છે. જો આપણે આનો ઉલ્લેખ ન કરીએ તો, તે અનંત લૂપમાં પરિણમી શકે છે.

કેવી રીતે જ્યારે લૂપ કામ કરે છે

નીચે ફ્લોચાર્ટ તમને જાવા કેવી રીતે બતાવે છે while લૂપ કામ કરે છે.

જાવા જ્યારે લૂપ

 

  • જ્યારે એક્ઝેક્યુશન કંટ્રોલ જ્યારે સ્ટેટમેન્ટ સ્ટેટમેન્ટ તરફ નિર્દેશ કરે છે, ત્યારે તે સ્થિતિ અથવા પરીક્ષણ અભિવ્યક્તિનું મૂલ્યાંકન કરે છે. સ્થિતિ કોઈપણ પ્રકારની હોઈ શકે છે ઓપરેટર.
  • જો શરત વળતર આપે છે a સાચું વેલ્યુ, તે જ્યારે લૂપની અંદર કોડ એક્ઝીક્યુટ કરે છે.
  • તે પછી સુધારાઓ વેરીએબલ વેલ્યુ ઇન્ક્રીમેન્ટ અથવા વેરીએબલ ઘટાડે છે. આ કોડને જાવાની અંદર રાખવો મહત્વપૂર્ણ છે જ્યારે લૂપ, નહીં તો, તે અનંત જાવાહિલે લૂપમાં પરિણમી શકે છે. અમે ટ્યુટોરીયલના અંત તરફ અનંત લૂપ પર ચર્ચા કરીશું.
  • ફરીથી જ્યારે સ્ટેટમેન્ટ તરફ ધ્યાન દોરો અને ઉપરોક્ત પગલાઓનું પુનરાવર્તન કરો.
  • જ્યારે સ્થિતિ પાછો આવે છે એ ખોટા વેલ્યુ, તે જાવામાંથી બહાર નીકળે છે જ્યારે લૂપ અને જ્યારે લૂપની બહાર સ્ટેટમેંટોના અમલ સાથે ચાલુ રહે છે

સરળ જાવા જ્યારે લૂપ ઉદાહરણ

નીચે એક સરળ કોડ છે જે લૂપ વખતે જાવા દર્શાવે છે.

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 સાથે પ્રારંભ કરો. જ્યારે સ્થિતિમાં, આપણી પાસે અભિવ્યક્તિ છે i <= 5, જેનો અર્થ થાય છે i વેલ્યુ 5 કરતા ઓછી અથવા બરાબર છે, તે લૂપને એક્ઝેક્યુટ કરે છે.

તેથી, 1 લી પુનરાવર્તનમાં, જ્યારે હું = 1, સ્થિતિ સાચી છે અને લૂપ વખતે જાવાની અંદર સ્ટેટમેન્ટ છાપે છે. તે પછી વૃદ્ધિ થાય છે i હવે 1 નો અર્થ થાય છે હું = 2.

તે પછી ફરી તપાસ કરે છે કે નહીં i <= 5. કારણ કે તે સાચું છે, તે ફરીથી લૂપની અંદર કોડ ચલાવે છે અને મૂલ્યમાં વધારો કરે છે.

તે ઉપરના પગલાંને પુનરાવર્તિત કરે છે હું = 5. આ તબક્કે, અંદર કોડ ચલાવવા પછી જ્યારે લૂપ, i કિંમત વૃદ્ધિ અને હું = 6. હવે શરત ખોટી આપે છે અને તેથી લૂપ વખતે જાવામાંથી બહાર નીકળી જાય છે.

જ્યારે એરેમાં લૂપ

તેના જેવું 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

સમજૂતી:

પ્રથમ, આપણે પૂર્ણાંકોની એરે પ્રારંભ કરીશું નંબરો અને જાવા જાહેર કરો જ્યારે લૂપ કાઉન્ટર ચલ i. તે એરે છે, તેથી આપણે છેલ્લા ઘટક સુધી એરેમાં બધા તત્વોમાંથી પસાર થવું જોઈએ. આ માટે, અમે લંબાઈનો ઉપયોગ કરીએ છીએ પદ્ધતિ જાવાની અંદર જ્યારે લૂપની સ્થિતિ. આનો અર્થ થાય છે જ્યારે સુધી લૂપ એક્ઝીક્યુટ થાય છે i મૂલ્ય એરેની લંબાઈ સુધી પહોંચે છે.

Iteration 1 જ્યારે i = 0: શરત: સાચું, સરવાળો = 20, i = 1

Iteration 2 જ્યારે i = 1: શરત: સાચું, સરવાળો = 30, i = 2

Iteration 3 જ્યારે i = 2: શરત: સાચું, સરવાળો = 70, i = 3

Iteration 4 જ્યારે i = 3: શરત: સાચું, સરવાળો = 120, i = 4

Iteration 5 જ્યારે i = 4: શરત: સાચું, સરવાળો = 150, i = 5

6 જ્યારે i = 5: શરત: ખોટું -> બહાર નીકળે ત્યારે Iteration XNUMX while લૂપ

અમારા નો સંદર્ભ લો કૃપા કરીને જાવામાં એરે એરે વિશે વધુ જાણવા ટ્યુટોરીયલ.

અનંત જ્યારે લૂપ

ટ્યુટોરીયલની શરૂઆતમાં ચર્ચા મુજબ, જ્યારે આપણે કાઉન્ટર વેરીએબલને યોગ્ય રીતે અપડેટ કરતા નથી અથવા શરતનો યોગ્ય રીતે ઉલ્લેખ કરતા નથી, ત્યારે તે અનંતમાં પરિણમે છે while લૂપ ચાલો આને નીચેના ઉદાહરણ સાથે જોઈએ.

public class infiniteWhileLoop {

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

  }

}

અહીં, આપણે વેરીએબલ શરૂ કર્યું છે જાવામાં જ્યારે લૂપની સ્થિતિમાં, આપણે ચકાસીએ છીએ કે કેમ i વેલ્યુ 0 થી વધારે અથવા બરાબર છે કારણ કે આપણે ઇન્ક્રીમેન્ટ કરીએ છીએ i જ્યારે લૂપની અંદરની કિંમત, સ્થિતિ i> = 0 જ્યારે હંમેશાં વળતર આપે છે સાચું મૂલ્ય અને અનંત અમલ કરશે.

આપણી પાસે અનંત જાવા પણ હોઈ શકે છે જ્યારે બીજી રીતથી લૂપ તમે નીચેના ઉદાહરણમાં જોઈ શકો છો. અહીં વેરીએબલની વેલ્યુ bFlag આપણે હંમેશાં વેરીએબલ વેલ્યુ અપડેટ ન કરતા હોવાથી હંમેશાં સાચું છે.

public class infiniteWhileLoop {

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

  }

}

તેથી અનંત જાવા જ્યારે લૂપ નીચે 2 સ્થિતિમાં થાય છે. જ્યારે જ્યારે લૂપનો ઉપયોગ કરો ત્યારે હંમેશા આ 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 જ્યારે લૂપ્સ છે. બાહ્ય જ્યારે લૂપ સુધી પુનરાવર્તિત થાય છે i <= 5 અને આંતરિક જ્યારે લૂપ સુધી પુનરાવર્તિત થાય છે j> = 5.

ક્યારે હું = 1, સ્થિતિ સાચી છે અને છાપે છે i મૂલ્ય અને પછી વૃદ્ધિ i મૂલ્ય ૧ દ્વારા. આગળ, તે આંતરિકને અમલ કરે છે જ્યારે વેલ્યુ સાથે લૂપ j = 10. શરત હોવાથી j> = 5 સાચું છે, તે j વેલ્યુ છાપે છે. હવે, તે અંદરની ક્રિયાને ચાલુ રાખે છે જ્યારે સ્થિતિ સુધી સંપૂર્ણપણે લૂપ થાય છે j> = 5 ખોટા વળતર આપે છે. એકવાર તે ખોટું થઈ જાય, તે લૂપ એક્ઝેક્યુશન સુધી બાહ્ય સાથે ચાલુ રહે છે i <= 5 ખોટા વળતર આપે છે.

આ શા માટે આઉટપુટમાં તમે છાપ્યા પછી જોઈ શકો છો હું = 1, તે બધા ચલાવે છે j સાથે શરૂ કિંમતો j = 10 ત્યાં સુધી j = 5 અને પછી છાપે છે i કિંમતો સુધી હું = 5. ક્યારે હું = 2, તે આંતરિક ચલાવતું નથી while સ્થિતિ ખોટી હોવાથી લૂપ.

જાવા જ્યારે બહુવિધ શરતો સાથે લૂપ

આપણી પાસે જાવાની અંદર મલ્ટીપલ વેરિયેબલ સાથે બહુવિધ સ્થિતિઓ હોઈ શકે છે જ્યારે લૂપ. નીચે આપેલા ઉદાહરણમાં, આપણી પાસે 2 ચલો છે a અને i વેલ્યુઝ 0. સાથે પ્રારંભ કરીશું. અહીં આપણે 0 અને 20 ની વચ્ચેની સમાન સંખ્યાઓ પ્રિન્ટ કરવા જઈશું. આ માટે, જાવા ની અંદર લૂપ વખતે આપણી કન્ડિશન છે. a <= 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

સંદર્ભ