A legelső programjaink egymás után végrehajtott utasítások sorozata voltak. Nincsenek villák. Ide tartozik a HelloWorld, amely üdvözlő üzenetet jelenít meg. Ez magában foglalja a számtani számításokat. Az első programjaink után megtanultuk az elágazást, azaz hogyan kell egy programot az adott körülményektől függően különböző műveleteket végrehajtani. Íme a központi fűtési és légkondicionáló rendszer vezérlésének kódja:
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
Tedd meg a következő lépést. A mindennapi életben gyakran hajtunk végre egységes ismétlődő cselekvéseket, például almát pucolunk egy pitéhez. Ez a lenyűgöző folyamat a következőképpen írható le:
Ha van alma a tálban, akkor végrehajtjuk az 1.1-1.4 lépéseket:
1.1. Fogj egy almát
1.2. Hámozzuk meg és vágjuk szeletekre
1.3. Az almaszeleteket egy serpenyőben elrendezzük a pite héjában
1.4. Térjen vissza az 1. lépéshez.
Tegyük fel, hogy van tíz almád, két kezed és egy késed. A való életben egymás után meghámozod az egész tucatot, ugyanazt az algoritmust követve minden almánál. De hogyan érhetjük el, hogy egy program ismétlődő műveletet hajtson végre minden almánál?
Az almák számához kötjük magunkat, de ha nem lenne elég belőlük, akkor a parancsok egy része "hasznos teher" nélkül futna (és esetleg megvágjuk magunkat egy nem létező alma megpucolása közben).
Ha több alma van, mint ahány parancsot kell meghámozni, akkor az alma egy része hámozatlanul marad.
Az ilyen kód nehezen olvasható. Sok ismétlés van benne, és nehéz módosítani.
A hurkok olyan utasítások, amelyek lehetővé teszik a műveletek ismételt végrehajtását
A Java while ciklusa jól működik a mi esetünkben. Ez a konstrukció több műveletet tömör és érthető szerkezetbe foglal. A while ciklus használatával egy pite almaszeletelő algoritmusa így nézhet ki Java nyelven:
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
arrangeInPie(apple.peel().slice());
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");
Parancs szintaxis
A while utasítás első változata a következő:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
Íme egy lépésről lépésre magyarázata annak, hogy mi történik, amikor ez a kód végrehajtódik:
Kiértékeljük a while kulcsszó utáni zárójelben található logikai kifejezést .
Ha a logikai kifejezés kiértékelése igaz, akkor a ciklustörzsben lévő utasítások végrehajtásra kerülnek. A ciklustörzs utolsó utasításának végrehajtása után továbblépünk az 1. lépésre
Ha a logikai kifejezés kiértékelése false, akkor a while ciklus utáni első utasításra ugrunk .
Hurok előfeltétellel
Mivel a ciklustörzs végrehajtása előtt mindig kiértékeljük a logikai kifejezést (a ciklusba való belépés feltételét) , a while ciklus ezen formáját gyakran előfeltételes ciklusnak nevezik . Készítsünk egy táblázatot egy szám első tíz hatványáról:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (exponent <= 10) { // The condition for entering the loop
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
}
}
Konzol kimenet:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
Hurok utófeltétellel
Íme a hurok második változata:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Íme annak magyarázata, hogy mi történik a kód végrehajtásakor:
A ciklustörzs végrehajtásra kerül (közvetlenül a do kulcsszó után).
Kiértékeljük a while kulcsszó utáni zárójelben található logikai kifejezést .
Ha a logikai kifejezés kiértékelése igaz, akkor továbblépünk az 1. lépésre
Ha a logikai kifejezés kiértékelése false, akkor a while ciklus utáni első utasításra ugrunk .
A két fő különbség az előző ciklushoz képest: 1) a ciklustörzs legalább egyszer végrehajtásra kerül, és 2) a logikai kifejezés a ciklustörzs végrehajtása után kerül kiértékelésre. Ennek megfelelően ezt a fajta while ciklust utófeltételes ciklusnak nevezzük . Ezúttal egy 10000-nél nem nagyobb szám hatványainak táblázatát jelenítjük meg:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = base; // The result of exponentiation
int exponent = 1; // The initial exponent
do {
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
result = result * base;
} while (result < 10000); // The condition for exiting the loop
}
Konzol kimenet:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Ügyeljen a kód változásaira. Hasonlítsa össze ezt az előfeltételes hurokkal.
Érdekes tények a hurkokkal való munkavégzésről
Elágazó utasítások a huroktörzsön belül
Két utasítás van, amely befolyásolja a cikluson belüli végrehajtást: break (amelyet a következő fejezetben részletesebben tárgyalunk) és
folytatni.
Tovább – kihagyja a ciklustörzs többi részének végrehajtását az aktuális iterációban, és a while utasítás logikai kifejezésének kiértékelésére ugrik. Ha a kifejezés kiértékelése igaz, akkor a ciklus folytatódik.
break – azonnal leállítja az aktuális iteráció végrehajtását, és átadja a vezérlést a ciklus utáni első utasításra. Így ez az utasítás befejezi az aktuális ciklus végrehajtását. A következő cikkben részletesebben megvizsgáljuk.
Emlékezzünk vissza a gyümölcspéldánkra. Ha nem vagyunk biztosak az almák minőségében, megváltoztathatjuk a kódot egy "
continue" utasítással:
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
if (apple.isBad()) { // This method returns true for rotten apples
apple.throwInGarbage();
continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
}
arrangeInPie(apple.peel().slice());
}
A
folytatódó utasítást gyakran használják, amikor a ciklustörzsben lévő utasításokat végre kell hajtani, ha egy bizonyos feltétel teljesül. Például előfordulhat, hogy egy hardveres érzékelő aktiválásakor műveleteket hajtunk végre (ellenkező esetben egyszerűen folytassuk azt a ciklust, amelyben az érzékelő leolvasását végezzük), vagy csak a ciklus bizonyos iterációira szeretnénk egy kifejezést kiszámítani. Az utóbbi esetre egy példát láthatunk, amikor egy while ciklust használunk a természetes számok kockáinak összegének kiszámításához, amelyek négyzete kisebb, mint a számok száma. Zavaros? Nézze meg a következő kódot:
public static void main(String[] args) {
int sum = 0; // Total amount
int i = 0; // Initial number in the series
int count = 20; // Number of numbers
while (i <= count) {
i++; // Get the next number — "i++" is equivalent to "i = i + 1"
if (i * i <= count) // If the square of the number is less than
continue; // the number of numbers, then we won't calculate the sum
// Jump to the next number in the loop
sum += i * i * i; // Otherwise, we calculate the sum of the cubes of numbers
} // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
System.out.println(sum); // Print the result
}
Végtelen hurok
Ezeket az elágazó utasításokat leggyakrabban végtelen ciklusokban használják. A ciklust végtelennek nevezzük, ha a ciklusból való kilépés logikai feltétele soha nem teljesül. Kódban valahogy így néz ki:
while (true) {
// Loop body
}
Ebben az esetben a
break utasítás segít kilépni a ciklusból. Ez a típusú hurok alkalmas arra, hogy a hurok testén kívül meghatározott külső feltételekre várjon. Például operációs rendszerekben vagy játékokban (a ciklusból való kilépés a játékból való kilépést jelenti). Vagy olyan algoritmusok használatakor, amelyek a ciklus minden iterációjával megpróbálnak javítani valamilyen eredményt, de korlátozzák az iterációk számát az eltelt idő vagy egy külső esemény (pl. dáma, sakk vagy időjárás előrejelzés) alapján. Ne feledje, hogy normál körülmények között a végtelen hurkok nem kívánatosak. Ennek bemutatásához térjünk vissza a hatványozáshoz:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (true) {
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
if (exponent > 10)
break; // Exit the loop
}
}
Konzol kimenet:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
Beágyazott hurkok
És most elérkezünk a hurkokról szóló utolsó témánkhoz. Emlékezzünk vissza arra az almás pitére (remélem, jelenleg nem vagy éhes) és az almapucoló hurkunkat:
Ha van alma a tálban, akkor végrehajtjuk az 1.1-1.4 lépéseket:
1.1. Fogj egy almát
1.2. Hámozzuk meg és vágjuk szeletekre
1.3. Az almaszeleteket egy serpenyőben elrendezzük a pite héjában
1.4. Térjen vissza az 1. lépéshez.
Írjuk le részletesebben a szeletelés folyamatát:
A szeletek száma = 0
Amíg a szeletek száma < 12, akkor hajtsa végre a 2.1-2.3 lépéseket
2.1. Vágjunk le egy másik szeletet az almáról
2.2. Szeletek száma++
2.3. Térjen vissza a 2. lépéshez
És ezt hozzáadjuk a tortakészítési algoritmusunkhoz:
Ha van alma a tálban, akkor végrehajtjuk az 1.1-1.6 lépéseket:
1.1. Fogj egy almát
1.2. Hámozza meg
1.3. A szeletek száma = 0
1.4. Amíg a szeletek száma < 12, akkor hajtsa végre az 1.4.1-1.4.3 lépéseket
1.4.1. Vágjunk le egy másik szeletet az almáról
1.4.2. Szeletek száma++
1.4.3. Térjen vissza az 1.4 lépéshez
1.5. Az almaszeleteket egy serpenyőben elrendezzük a pite héjában
1.6. Térjen vissza az 1. lépéshez.
Most van egy hurok a hurkon belül. Az ehhez hasonló konstrukciók nagyon gyakoriak. Utolsó példaként építsük meg az egyik szorzótáblát, amelyet általános iskolában tanultunk szeretni.
public static void main(String[] args) {
// Print the second factors in a row
System.out.println(" 2 3 4 5 6 7 8 9");
int i = 2; // Assign the first factor to the variable
while (i < 10) { // First loop: execute as long as the first factor is less than 10
System.out.print(i + " | "); // Print the first factor at the beginning of the line
int j = 2; // The starting value of the second factor
while (j < 10) { // Second loop: execute as long as the second factor is less than 10
int product = i * j; // Calculate the product of the factors
if (product < 10) // If the product is a single digit, then we print two spaces after the product
System.out.print(product + " ");
else // Otherwise, print the product and one space after it
System.out.print(product + " ");
j++; // Increment the second factor by one
} // Go to the beginning of the second loop, i.e. "while (j < 10)"
System.out.println(); // Move to the next line on the console
i++; // Increment the first factor by one
} // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
A ciklusok (különösen a
while utasítás) a szoftverek egyik alapvető építőkövei. Ha feladatokat old meg a CodeGym-en, megtanulja az összes különféle hurkot, megérti azok bonyolultságát, és gyakorlati készségekre tesz szert a használatukban.
Tegyük fel, hogy van tíz almád, két kezed és egy késed. A való életben egymás után meghámozod az egész tucatot, ugyanazt az algoritmust követve minden almánál. De hogyan érhetjük el, hogy egy program ismétlődő műveletet hajtson végre minden almánál?
GO TO FULL VERSION