Pętla w językach programowania to funkcja, która ułatwia wielokrotne wykonanie zestawu instrukcji/funkcji, gdy jakiś warunek ma wartość true. Java udostępnia trzy sposoby wykonywania pętli. Chociaż wszystkie sposoby zapewniają podobną podstawową funkcjonalność, różnią się składnią i czasem sprawdzania warunków.
Java udostępnia trzy typy instrukcji warunkowych. Drugi typ to instrukcja pętlowa.
- pętla while: Pętla while to instrukcja przepływu sterowania, która umożliwia wielokrotne wykonanie kodu w oparciu o dany warunek logiczny. Pętlę while można traktować jako powtarzającą się instrukcję if.
Składnia:
while (boolean condition) { loop statements... }> Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >while> (i<=>10>)> >{> >System.out.println(i);> >i++;> >}> >}> }> |
>
>Wyjście
0 1 2 3 4 5 6 7 8 9 10>
- Schemat blokowy:
- Pętla while rozpoczyna się od sprawdzenia warunku logicznego. Jeśli zostanie oceniony jako true, wówczas wykonywane są instrukcje treści pętli, w przeciwnym razie wykonywana jest pierwsza instrukcja po pętli. Z tego powodu jest również nazywany Pętla kontroli wejścia
- Gdy warunek zostanie uznany za prawdziwy, wykonywane są instrukcje zawarte w treści pętli. Zwykle instrukcje zawierają wartość aktualizacji zmiennej przetwarzanej w następnej iteracji.
- Kiedy warunek staje się fałszywy, pętla kończy się, co oznacza koniec jej cyklu życia.
- dla pętli: for zapewnia zwięzły sposób pisania struktury pętli. W przeciwieństwie do pętli while, instrukcja for zajmuje inicjalizację, warunek oraz przyrost/zmniejszenie w jednym wierszu, zapewniając w ten sposób krótszą, łatwą do debugowania strukturę pętli.
Składnia:
for (initialization condition; testing condition;increment/decrement) { statement(s) }> Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for> (>int> i=>0>;i<=>10>;i++)> >{> >System.out.println(i);> >}> >}> }> |
>
>Wyjście
0 1 2 3 4 5 6 7 8 9 10>
- Schemat blokowy:
- Warunek inicjalizacji: Tutaj inicjujemy używaną zmienną. Oznacza początek pętli for. Można użyć już zadeklarowanej zmiennej lub zadeklarować zmienną, tylko lokalnie w pętli. Warunek testowania: Służy do testowania warunku wyjścia pętli. Musi zwracać wartość logiczną. Jest to również Pętla kontroli wejścia ponieważ warunek jest sprawdzany przed wykonaniem instrukcji pętli. Wykonanie instrukcji: Po uznaniu warunku za prawdziwy, wykonywane są instrukcje zawarte w treści pętli. Zwiększanie/zmniejszanie: służy do aktualizacji zmiennej dla następnej iteracji. Zakończenie pętli: gdy warunek staje się fałszywy, pętla kończy się, co oznacza koniec jej cyklu życia.
- zrobić podczas: pętla do while jest podobna do pętli while z tą tylko różnicą, że sprawdza warunek po wykonaniu instrukcji i dlatego jest przykładem Wyjdź z pętli kontrolnej.
Składnia:
do { statements.. } while (condition);> Jawa
Java i swing
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >do> >{> >System.out.println(i);> >i++;> >}>while>(i<=>10>);> >}> }> |
>
>Wyjście
0 1 2 3 4 5 6 7 8 9 10>
- Schemat blokowy:
- pętla do while rozpoczyna się wykonaniem instrukcji. Za pierwszym razem nie sprawdza się żadnego warunku.
- Po wykonaniu instrukcji i aktualizacji wartości zmiennej sprawdzany jest warunek pod kątem wartości prawdziwej lub fałszywej. Jeżeli zostanie ocenione jako true, rozpoczyna się następna iteracja pętli.
- Kiedy warunek staje się fałszywy, pętla kończy się, co oznacza koniec jej cyklu życia.
- Należy zauważyć, że pętla do-while wykona swoje instrukcje co najmniej raz przed sprawdzeniem dowolnego warunku i dlatego jest przykładem pętli kontroli wyjścia.
Pułapki pętli
- Nieskończona pętla: Jednym z najczęstszych błędów podczas wdrażania jakiejkolwiek pętli jest to, że może ona nigdy nie zostać zakończona, co oznacza, że pętla działa przez nieskończony czas. Dzieje się tak, gdy z jakiegoś powodu warunek nie zostanie spełniony. Przykłady: Nieskończona pętla for:
Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
nieskończona pętla while:
Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >while> (>true>)> >{> >// statement> >}> > >}> }> |
>
>
Jawa
//Java program to illustrate various pitfalls.> public> class> LooppitfallsDemo> {> >public> static> void> main(String[] args)> >{> >// infinite loop because condition is not apt> >// condition should have been i>0.> >for> (>int> i =>5>; i !=>0>; i -=>2>)> >{> >System.out.println(i);> >}> >int> x =>5>;> >// infinite loop because update statement> >// is not provided.> >while> (x ==>5>)> >{> >System.out.println('In the loop');> >}> >}> }> |
>
>
Kolejną pułapką jest to, że możesz dodawać coś do obiektu kolekcji za pomocą pętli i może zabraknąć pamięci. Jeśli spróbujesz wykonać poniższy program, po pewnym czasie zostanie zgłoszony wyjątek braku pamięci.
Jawa
//Java program for out of memory exception.> import> java.util.ArrayList;> public> class> Integer1> {> >public> static> void> main(String[] args)> >{> >ArrayList ar =>new> ArrayList();> >for> (>int> i =>0>; i { ar.add(i); } } }> |
>
>
Wyjście:
Exception in thread 'main' java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Unknown Source) at java.util.Arrays.copyOf(Unknown Source) at java.util.ArrayList.grow(Unknown Source) at java.util.ArrayList.ensureCapacityInternal(Unknown Source) at java.util.ArrayList.add(Unknown Source) at article.Integer1.main(Integer1.java:9)>
Zagnieżdżona pętla:
Pętla zagnieżdżona oznacza instrukcję pętli znajdującą się wewnątrz innej instrukcji pętli.
Istnieją różne kombinacje użycia pętli Do pętla, chwila pętla, zrobić podczas pętla.
Przykład 1 Zagnieżdżona pętla for
Jawa
odczytać z pliku csv w Javie
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for>(>int> i =>0>; i <>3>; i++){> >for>(>int> j =>0>; j <>2>; j++){> >System.out.println(i);> >}> >System.out.println();> >}> >}> }> |
>
>Wyjście
0 0 1 1 2 2>
Przykład 2 Zagnieżdżona pętla while
Jawa
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> i =>1>, j =>1>;> >while> (i <=>3>) {> >while> (j <=>3>) {> >System.out.print(j);> >j++;> >}> >i++;> >System.out.println(>''>);> >j =>1>;> >}> >}> }> |
>
>Wyjście
123 123 123>
Przykład 3. Zagnieżdżona pętla do while
Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> row =>1>, column =>1>;> >int> x;> >do> {> >x =>4>;> >do> {> >System.out.print(>''>);> >x--;> >}>while> (x>= wiersz);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Wyjście
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5>
Przykład 4 Zagnieżdżone pętle while i for
Jawa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> weeks =>3>;> >int> days =>7>;> >int> i =>1>;> >// outer loop> >while> (i <= weeks) {> >System.out.println(>'Week: '> + i);> >// inner loop> >for> (>int> j =>1>; j <= days; ++j) {> >System.out.println(>' Days: '> + j);> >}> >++i;> >}> >}> }> |
>
>Wyjście
Week: 1 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 2 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 3 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7>