Pętla for w Javie: składnia, przykłady i rozszerzone for-each

Klasyczna pętla for z trzema częściami

Pętla for powtarza blok kontrolowaną liczbę razy. W Javie w nawiasach mieszczą się trzy elementy oddzielone średnikami:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Te trzy części wykonują się w stałym rytmie:

1. Inicjalizacja (int i = 0): wykonuje się raz, przed wszystkim innym.
2. Warunek (i < 5): sprawdzany przed każdym przebiegiem; pętla kończy się, gdy jest fałszywy.
3. Aktualizacja (i++): wykonuje się po każdym przebiegu, zanim warunek zostanie sprawdzony ponownie.

Program wypisuje więc od i = 0 do i = 4. Licznik i istnieje tylko w pętli: po zamykającym nawiasie klamrowym już go nie ma.

Liczenie w górę, w dół i co krok

Trzy części dają pełną kontrolę nad licznikiem:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // odliczanie w dół
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // krok co 5
            System.out.print(i + " ");
        }
    }
}

i-- zmniejsza licznik, a i += 5 przeskakuje o pięć: oba to arytmetyczne operatory, które liczą wartość licznika. Warunek decyduje o zatrzymaniu zależnie od kierunku: używaj > przy odliczaniu w dół, a < lub <= przy liczeniu w górę.

Pętla po tablicy

Pętla z licznikiem naturalnie łączy się z tablicą: .length służy jako granica, a i jako indeks:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

Zauważ, że colors.length to pole bez nawiasów: pod tym względem tablice są wyjątkowe. List używa zamiast tego list.size(). Warunek i < colors.length jest poprawny: indeksy biegną od 0 do length - 1, więc użycie < (a nie <=) chroni przed wyjściem poza zakres.

Rozszerzona pętla for-each

Gdy potrzebujesz tylko kolejnych elementów, a nigdy indeksu, rozszerzone for jest czytelniejsze i trudniej w nim o błąd: nie ma licznika, który mógłby się pomylić o jeden:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

Czytaj for (String color : colors) jako „dla każdego koloru w colors”. Działa na tablicach i na wszystkim, po czym można iterować. Cena: nie masz indeksu i nie możesz dodawać ani usuwać elementów kolekcji w trakcie pętli (to rzuca wyjątek w czasie działania, ConcurrentModificationException). Gdy potrzebujesz jednego z nich, sięgnij po pętlę z licznikiem.

Pętle zagnieżdżone

Pętla w pętli przydaje się do siatek, tabel i łączenia w pary. Wewnętrzna pętla wykonuje się w całości przy każdym przebiegu zewnętrznej:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Ten kod wypisuje tabliczkę mnożenia 3x3. Przy głębszym zagnieżdżeniu nadawaj licznikom znaczące nazwy (row, col) zamiast i, j: łatwiej wtedy odróżnić, który jest który.

break i continue

break natychmiast opuszcza pętlę. continue pomija resztę bieżącego przebiegu i przechodzi do kroku aktualizacji:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // pomija liczby parzyste
            if (i > 7) break;           // kończy po przekroczeniu 7
            System.out.println(i);
        }
    }
}

Program wypisuje 1 3 5 7. continue pomija liczby parzyste, a break kończy pętlę, gdy i przekroczyłoby 7. W pętlach zagnieżdżonych oba działają tylko na najbardziej wewnętrzną pętlę, chyba że użyjesz break z etykietą.

Uważaj na pętle nieskończone

Jeśli warunek nigdy nie stanie się fałszywy, pętla działa w nieskończoność. Zwykle przyczyną jest zapomniana aktualizacja albo zmiana licznika w złą stronę:

for (int i = 0; i < 5; i--) {   // i tylko maleje -> nigdy nie osiągnie 5
    System.out.println(i);
}

Celowa pętla nieskończona pomija wszystkie trzy części, for (;;) { ... }, i polega na break w środku, aby się zatrzymać. Używaj jej oszczędnie; while (true) zwykle czyta się łatwiej.

Dalej: pętle while

Pętla for sprawdza się, gdy znasz licznik z góry. Gdy chcesz powtarzać kod, dopóki nie zmieni się jakiś warunek, a nie masz wygodnego licznika, lepiej pasuje pętla while. To temat następnej strony.