16. diel - Cykly v Jave do tretice - do-while, break a continue

V minulej lekcii, Podmienky v Jave - Ternárny výraz, prepadávací switch, sme sa venovali ďalšej syntaxi podmienok.

V dnešnom Java tutoriále sa pozrieme na cyklus do-while, príkazy break a continue a tiež na skrátený zápis už prebraného cyklu for. Tutoriál obsahuje menej používané praktiky a slúži hlavne na to, aby vás neprekvapili v cudzom kóde. Zatiaľ nie je príliš dôležité, aby ste ich sami vedeli používať.

Cyklus do-while

Cyklus while už dobre poznáme. Menej používaný do-while sa líši iba tým, že sa vždy vykoná najmenej raz. Jeho podmienka je totiž umiestnená až za telom cyklu. Vyzerá teda takto:

do {
    // code
} while (condition);

Príklad - Kalkulačka

Použitie do-while cyklu si ukážme na našej kalkulačke z lekcie Cykly v Jave.

Varianta s while

V kalkulačke sme použili cyklus while, ktorý umožnil celý program opakovať a tak zadávať ďalšie a ďalšie príklady. Kód vyzeral takto (jedná sa o verziu s konštrukciou switch):

Scanner scanner = new Scanner(System.in, "Windows-1250");

System.out.println("Welcome to our calculator");
String goOn = "yes";
while (goOn.equals("yes")) {
    System.out.println("Enter the first number:");
    double a = Double.parseDouble(scanner.nextLine());
    System.out.println("Enter the second number:");
    double b = Double.parseDouble(scanner.nextLine());
    System.out.println("Choose one of the following operations:");
    System.out.println("1 - addition");
    System.out.println("2 - subtraction");
    System.out.println("3 - multiplication");
    System.out.println("4 - division");
    int option = Integer.parseInt(scanner.nextLine());
    double result = 0;
    switch (option) {
        case 1:
            result = a + b;
            break;
        case 2:
            result = a - b;
            break;
        case 3:
            result = a * b;
            break;
        case 4:
            result = a / b;
            break;
    }
    if ((option > 0) && (option < 5)) {
        System.out.println("Result: " + result);
    } else {
        System.out.println("Invalid option");
    }
    System.out.println("Would you like to make another calculation? [yes/no]");
    goOn = scanner.nextLine();
}
System.out.println("Thank you for using our calculator.");

Všimnite si, že sme sa pri tomto variante s while museli zamyslieť nad východiskovou hodnotou premennej goOn, ktorej sme nastavili hodnotu yes, aby bola podmienka splnená pre prvý prechod cyklom. Vymyslieť východiskovú hodnotu môže byť niekedy pomerne zložité a treba aj vyžadovať pomocnú premennú. V tomto prípade je vhodnejšie využiť cyklus do-while.

Varianta s do-while

Keď použijeme cyklus do-while, tak predvolenú hodnotu danej premennej nemusíme riešiť:

Scanner scanner = new Scanner(System.in, "Windows-1250");

System.out.println("Welcome to our calculator");
String goOn;
do {
    System.out.println("Enter the first number:");
    double a = Double.parseDouble(scanner.nextLine());
    System.out.println("Enter the second number:");
    double b = Double.parseDouble(scanner.nextLine());
    System.out.println("Choose one of the following operations:");
    System.out.println("1 - addition");
    System.out.println("2 - subtraction");
    System.out.println("3 - multiplication");
    System.out.println("4 - division");
    int option = Integer.parseInt(scanner.nextLine());
    double result = 0;
    switch (option) {
        case 1:
            result = a + b;
            break;
        case 2:
            result = a - b;
            break;
        case 3:
            result = a * b;
            break;
        case 4:
            result = a / b;
            break;
    }
    if ((option > 0) && (option < 5)) {
        System.out.println("Result: " + result);
    } else {
        System.out.println("Invalid option");
    }
    System.out.println("Would you like to make another calculation? [yes/no]");
    goOn = scanner.nextLine();
} while (goOn.equals("yes"));
System.out.println("Thank you for using our calculator.");

Príkazy break a continue

Beh cyklu je potrebné niekedy prerušiť, k tomu máme nasledujúce dve kľúčové slová.

Príkaz break

Príkaz break ukončuje aktuálny cyklus. Najčastejšie sa používa, ak pomocou cyklu nájdeme nejakú položku v kolekcii a ďalej už v jej prechádzaní nechceme pokračovať. Nebudeme tak ďalej zbytočne prehľadávať zvyšok kolekcie, keď už máme to, čo sme hľadali.

Príklad s využitím break

Predstavme si, že máme veľké a malé štítky na poháre a chceme použiť na všetky poháre buď jedny alebo druhé. Zaujíma nás teda, či sa text všetkých popisov zmestí na malé štítky. Napíšeme program, ktorý zistí, či je v poli slovo dlhšie ako 6 znakov. Pokiaľ áno, musíme použiť väčšie štítky.

Začneme cyklom prechádzať jednotlivé slová a akonáhle nájdeme slovo dlhšie ako 6 znakov, tak si uložíme jeho index. Zatiaľ stále nič nové pod slnkom. V tej istej chvíli však pomocou príkazu break cyklus ukončíme.

Ukážka použitia príkazu break:

{JAVA_CONSOLE}
String[] fruits = {"Apples", "Pears", "Plums", "Apricots", "Strawberries", "Cherries"};
int index = -1;

for (int i = 0; i < fruits.length; i++) {
    if (fruits[i].length() > 6) {
        index = i;
        break;
    }
}

if (index >= 0)
    System.out.println("First word longer than 6 characters: " + fruits[index]);
{/JAVA_CONSOLE}

Výstup programu:

Konzolová aplikácia
First word longer than 6 characters: Apricots

Príkaz break sa v praxi často nahrádza príkazom return za predpokladu, že je kód v našej vlastnej metóde. Vlastné metódy sa ale naučíme deklarovať až v nadväzujúcom kurze Základy objektovo orientovaného programovania v Jave. Potom príkaz break odporúčam skôr nepoužívať, správnejší variant je kód pre prácu s kolekciou vyčleniť do samostatnej funkcie.

Príkaz continue

Príkaz continue je podobný príkazu break. Používa sa však na ukončenie iba aktuálnej iterácie (priebehu) cyklu a nie celého cyklu. Cyklus potom rovno prechádza na ďalšiu iteráciu. Použitie continue môžeme nájsť napr. pri validovaní položiek pri prechádzaní nejakej kolekcie.

Príklad s využitím continue

Predstavme si, že máme od používateľa zadané čísla a chceme ich sčítať. Používateľ tieto čísla zadá ako jeden reťazec, kde je každé číslo oddelené čiarkou. Bohužiaľ musíme počítať aj s tým, že používateľ zadá namiesto čísla nejaký nezmysel. Riešenie by mohlo vyzerať nasledovne:

{JAVA_CONSOLE}
String input = "10,50,ab10cd,30,9";
// parsing a string into an array
String[] items = input.split(",");
int sum = 0;
for (String item : items) {
    // verification that the variable does not contain any non-numeric characters
    if (!item.matches("\\d+"))
        continue;
    // converting a string to an integer
    int number = Integer.parseInt(item);

    sum += number;
}
System.out.println("Sum is: " + sum);
{/JAVA_CONSOLE}

Výstup programu:

Konzolová aplikácia
Sum is: 99

Program sčíta všetky správne zadané hodnoty. Formát reťazca overujeme pomocou metódy matches(). Kým sa budeme naplno týmito regulárnymi výrazmi zaoberať, bude nám stačiť, že výraz \\d+ vráti true, pokiaľ je text len celé kladné číslo. Pri nesprávne zadaných hodnotách je aktuálna iterácia ukončená. Namiesto príkazu continue by sme samozrejme mohli použiť len príkaz if.

Skrátený zápis cyklu for

Nasledujúce konštrukcie sú tu pre ukážku, s čím všetkým je možné sa stretnúť v cudzích kódoch a nie je dobrý dôvod tieto konštrukcie používať !

Cyklus for je možné zapísať takto skrátene bez tela cyklu:

{JAVA_CONSOLE}
for (int i = 0; i < 10; System.out.print(i++));
{/JAVA_CONSOLE}

Výstup:

Konzolová aplikácia
0123456789

Písať logiku priebehu behu cyklu aj logiku v cykle na jeden riadok však nie je intuitívne. Navyše sa tak môže ľahko zabudnúť na inkrementáciu premennej alebo ju inkrementovať viackrát.

Dokonca nie je nutné v hlavičke cyklu for uvádzať akýkoľvek príkaz:

for (;;) {
    // infinite cycle
}

Tento zápis je rovnaký ako:

while (true) {
    // infinite cycle
}

Oba vyššie deklarované cykly bežia donekonečna a môžete ich stretnúť v zle napísaných zdrojových kódoch spolu s príkazmi break, ktoré z nich potom za nejakých podmienok vyskakujú.

Akonáhle podmienka nie je priamo v deklarácii cyklu, je pomerne neprehľadné zistiť, kedy cyklus vôbec skončí a ľahké urobiť z takého cyklu nechtiac nekonečný. To platí obzvlášť, keď z cyklu vyskakujeme viacerými podmienkami a nepokryjeme všetky možné prípady.

Hoci dnešný tutoriál obsahoval štandardnú gramatiku Javy pre cykly, z nových konštrukcií používajte iba do-while a continue. Prechodne ešte môžete používať príkaz break, než sa dostaneme k objektom

V budúcej lekcii, Matematické funkcie v Jave a knižnica Math, sa pozrieme na matematické funkcie a základný kurz úplne zakončíme.