Web Analytics Made Easy - Statcounter
SVET PROGRAMIRANJA

Uvod u petlje(cikluse) u programskom jeziku JAVA

Petlje u programiranju su kontrolne strukture koje omogućavaju izvršavanje skupa instrukcija više puta, dokle god je zadati uslov ispunjen. Njihova glavna svrha je automatizacija ponavljanja zadataka, čime se smanjuje potreba za pisanjem koda koji se ponavlja. Umesto da ručno pišemo više linija koda za svaku iteraciju, petlje nam omogućavaju da jedan blok koda ponovimo za određeni broj puta ili dok neki uslov ne postane netačan. Najčešće korišćene petlje su for, while, i do-while petlje, svaka prilagođena različitim situacijama.

Poređenje performansi između različitih tipova petlji

U Javi, performanse različitih petlji zavise od broja iteracija i same logike:
  1. for petlja: Efikasna kada znamo tačan broj iteracija unapred. Dobar je izbor za nizove i iteracije kroz fiksne strukture podataka.
  2. while petlja: Bolja za situacije gde broj iteracija nije unapred poznat. Može biti manje efikasna ako uslov dugo ostane true.
  3. do-while petlja: Slična while petlji, ali će se kod uvek izvršiti makar jednom, što može biti važno u određenim slučajevima.
U praksi, razlike u performansama između ovih petlji su minimalne za većinu aplikacija, osim u slučajevima kada se radi sa veoma velikim skupovima podataka.
Ovde možemo dodati i foreach petlju.
foreach petlja se ne smatra posebnim tipom petlje, već spada u grupu iterativnih petlji, slično kao for petlja. Dok se klasična for petlja koristi za iteraciju kroz niz sa eksplicitno navedenim indeksima i kontrolnim promenljivama, foreach petlja pojednostavljuje iteraciju kroz kolekcije (kao što su nizovi, liste ili mape), prolazeći automatski kroz svaki element bez potrebe za eksplicitnim indeksiranjem. Iako funkcionalno različita, može se smatrati specijalizovanim oblikom for petlje prilagođene kolekcijama.

Algoritam for petlje-dijagram

Ovaj algoritam prikazuje kako se kontroliše ponavljanje naredbi sa tri izraza: 1 - definiše se i inicijalizuje neka promenljiva; 2 -  postavlja se logički izraz kao uslov petlje; 3 - definiše promenu vrednosti kontrolne promenljive tokom ciklusa
​
Algoritam for petlje-dijagram(opšti)
Slika 1: Algoritam for petlje-dijagram(opšti)
Ovde se vidi konkretan primer za 3 izraza koji služe za kontrolu toka: 1 - definiše se i inicijalizuje promenljiva "i" i inicijalizuje na vrednost nula; 2 -  postavlja se logički izraz i<n kao uslov petlje; 3 - definiše promenu kontrolne promenljive za "+1" tokom ciklusa 
Algoritam for petlje-dijagram(primer)
Slika 2. Algoritam for petlje-dijagram(primer)

Algoritam while, kao i do-while petlje, dijagrami

Definiše se ponavljanje grupe naredbi sve dokle je zadovoljen neki postavljen uslov(logički izraz). Ova petlja se obično koristi kada unapred nije poznat broj izvršavanja ciklusa. Može se desiti da ne postoji nijedan slučaj ponavljanja.
​
Algoritam while petlje-dijagram(opšti)
Slika 3: Algoritam while petlje-dijagram(opšti)
Definiše se ponavljanje grupe naredbi sve dokle je zadovoljen neki postavljen uslov(logički izraz). Ova petlja se obično koristi kada unapred nije poznat broj izvršavanja ciklusa i kada nam je iz nekog razloga važno da postoji bar jedan ciklus. Mora se izvršiti bar jedan ciklus.
Algoritam do - while petlje-dijagram(opšti)
Slika 4: Algoritam do - while petlje-dijagram(opšti)
Ovu lekciju u C/C++ jeziku možete pročitati na sledećoj strani: Petlje u programskom jeziku C/C++
Da bi ste vežbali primere iz ove blasti idite na stranu: Petlje u JAVI-primeri.

Odakle potreba za komandom petlje

​Posmatrajmo sledeći problem. Želimo da ispišemo niz prirodnih brojeva.Neka to u ovom primeru bude niz prvih 10 prirodnih brojeva. Naredba kojom bi ispisali broj 1 je:
System.out.print(“1”);
Ako želimo da ispišemo i ostale brojeve, mogli bismo to uraditi tako što ćemo prethodnu naredbu ponoviti 10 puta (koristimo Copy – Paste) i pri tome promeniti samo vrednost broja koji se prikazuje
System.out.print(“1, ”);
System.out.print(“2, ”);
System.out.print(“3, ”);
System.out.print(“4, ”);
System.out.print(“5, ”);
...

for ciklus u java programskom jeziku

Ovo bi još moglo da se uradi na ovaj način za malo brojeva, ali šta ako treba ispisati niz od 100, 1000 brojeva. Naravno, to se na ovaj način ne bi radilo.
Ideja korišćenja ciklusa je da se naredbe koje se ponavljaju napišu samo jedanput, a da se korišćenjem naredbe za stvaranje ciklusa kao  npr. naredbe for, ove naredbe više puta izvrše, tj. onoliko puta koliko je potrebno.
U ovom primeru naredba koja se ponavlja je

 System.out.print(..

Dakle, mi ćemo je napisati samo jednom i ubaciti u telo naredbe for koja predstavlja ciklus:
U opštem slučaju naredba for se zapisuje:
System.out.print(“1, ”);
for(inicijalizacija; uslov_petlje; izraz_petlje)
{
niz_naredbi;
}
U našem primeru u pitanju je samo jedna naredba i ona se piše unutar vitičastih zagrada i to bi izgledalo:
System.out.print(“1, ”);
for(inicijalizacija; uslov_petlje; izraz_petlje)
{
System.out.print(..
}
Uslovi koje treba napisati, a koji određuju broj ponovljenih ciklusa se pišu u maloj zagradi i to su: inicijalizacija, uslov_petlje, izraz_petlje i oni su unutar te male zagrade razdvojeni sa tačka-zarez.
Inicijalizacija znači da uvedemo(definišemo) neku kontrolnu promenljivu npr "i", a to znači da rezervišemo za nju memoriju i da joj damo početnu vrednost(inicijalizujemo je).
U ovom primeru:
int i = 1;
uslov petlje predstavlja neki logički izraz koji može biti tačan(true) ili netačan(false). U našem primeru to je:
i<= 10;
Ciklus će se ponavljati dokle god bude ovaj uslov ispunjen. Kada tokom ciklusa promenljivu "i" ne bi menjali, a možemo je menjati kroz izraz petlje, uslov bi uvek bio ispunjen, tj. ciklus se nikada ne bi prekinuo(beskonačan ciklus).Da bi se on prekinuo mora se napraviti da uslov ne bude zadovoljen(false). Kontrolnu promenljivu i možemo menjati pomoću:
izraz_petlje i to je obično izraz oblika
i = i + korak;
gde je korak ceo broj koji predstavlja vrednost za koliko se promenljiva "i" povećava ili smanjuje(ako je korak negativna vrednost). U našem primeru vrednost "i" treba da se povećava u svakom ciklusu za 1, pa će izraz petlje glasiti:
i = i + 1;
Ovo znači da u memorijskom prostori i nova vrednost je za 1 veća od prethodne. For ciklus sada izgleda:
for(int i = 1; i<=10; i= i+1)
{
System.out.print(..
}
Naredba će se sada ponoviti 10 puta tj. sve dok je i<=10. Ostaje da se vidi šta da se stavi u zagrade print naredbe. Ako bi napisali „1“, ispisalo bi se 1,1,1,1,1,1...
Potrebno je staviti promenljivu koja će u prvom ciklusu imati vrednost 1, u drugom 2 itd. To može biti upravo promenljiva i koja nam služi za kontrolu broja ciklusa. Sada konačno možemo napisati:
for(int i = 1; i<=10; i= i+1)
{
System.out.print( i+”, ”);
}
Naravno, ovaj zadatak je mogao da se reši i sa naredbom
System.out.print( ”1,2,3,4,5,6,7,8,9,10 ”);
ali smo ovde samo hteli da pokažemo for naredbu za cikluse i kada i zašto se oni koriste.
Ciklus for se inače koristi kada unapred znamo koliko će biti ciklusa, a ako ne znamo onda će se koristiti ili ciklus while ili do-while, o čemu će biti reči kasnije.
Za izraz_petlje se može koristiti operator "++" za povećanje vrednosti promenljive "i" za vrednost 1 umesto izraza i=i+1
for(int i = 1; i<=10; i++)
{
System.out.print( i+”, ”);
}

Tekst zadatka: Sabrati niz prvih 10 prirodnih brojeva upotrebom for ciklusa.

I ovaj zadatak bi mogao da se reši naredbom
System.out.print( ””+(1+2+3+4+5+6+7+8+9+10) );

ali hoćemo da pokažemo kako bi se korišćem for ciklusa dobio zbir(pogodno kada ima puno brojeva). Ideja je da se u svakom ciklusu doda po jedan prirodan broj u neku promenljivu koja predstavlja zbir. Ti prirodni brojevi bi u ciklusu bili obeleženi sa promenljivom "i" kao i u prethodnom primeru(pogodno je jer se ta promenljiva menja od 1 do 10 tokom ciklusa sa korakom 1, tako da ona kroz cikluse zapravo predstavlja te prirodne brojeve koje treba sabrati.
Prvo je potrebno uvesti promenljivu koja će predstavljati zbir:
int zbir=0;
Zatim bi trebalo u zbir dodavati jedan po jedan broj. Napisano bez ciklusa to bi izgledalo:
          zbir = zbir + 1;
          zbir = zbir + 2;
          zbir = zbir + 3;
         zbir = zbir + 4;
...
         zbir = zbir + i;
...
         zbir = zbir + 10;
ali umesto toga koristimo ciklus:
for(int i = 1; i<=10; i= i+1)
{
zbir = zbir + i;
}
Konačan zbir će biti formiran tek po završetku for ciklusa. Kompletan primer je prikazan na slici ispod.
class Sabiranje {
public static void main(String[]args)
{
int zbir=0;
for(int i = 1; i<=10; i= i+1)
{
zbir = zbir + i;
}
System.out.println("zbir="+zbir);
}
}
I posle pokretanja:
for ciklusi - Sabiranje aplikacija izvršenje
Slika 5: for ciklusi - Sabiranje aplikacija izvršenje

PRIMER Prosecna ocena:

Tekst zadatka: Ucitati broj predmeta n, a zatim ucitati ocene iz n predmeta, sabrati ih i izracunati prosecnu ocenu. Rezultat prikazati na ekranu.
Uputstvo: Ucitati n preko Input dijaloga. S obzirom da ima više ocena za učitavanje koristiti for ciklus. Sabiranje ocena uraditi u for ciklusu kao što je to urađeno u prethodnom primeru.Tek kada se izračuna konačan zbir ocena, a to je posle for ciklusa, može se dalje računati prosek.
​

CIKLUS while sa uslovom na početku

Ciklus u opštem slučaju izgleda:
while(uslov_petlje)
{
NAREDBE
}
WHILE petlja - algoritam
Slika 6: WHILE petlja - algoritam
Za razliku od for koji se koristi kad unapred znamo broj ciklusa, while se koristi kada ne znamo unapred kada će se ciklus prekinuti.
Na slici se može  uočiti petlja,(zatvoren krug) u kojoj se nalaze naredbe za ponavljanje. Ove naredbe će se ponavljati sve dok bude bio ispunjen postavljen USLOV. To je logički izraz ili promenljiva tipa boolean koja može da bude true ili false. Prvi put kad uslov bude false, ciklus će se prekinuti i program nastavlja da se izvršava izvan while petlje.
Pogledajmo sledeći primer:

PRIMER Kviz:

Tekst zadatka: Učitati vrednosti osvojenih bodova za tekuće pitanje na nekom kvizu.Odrediti posle koliko pitanja će kandidat da dostigne vrednost  30 bodova, ako za svako pitanje može da osvoji 1-10 bodova. Računanje bodova prekinuti posle najviše 10 pitanja.
int brojBodova;
int ukupnoBodova=0;
Scanner ucitavac=new Scanner(System.in);
Bodove ćemo učitavati kroz ciklus i dodavati ih ukupnom broju bodova:
while(ukupnoBodova < 30)
{
System.out.println("Unesite broj bodova");
ukupnoBodova=ucitavac.nextInt();
ukupnoBodova=ukupnoBodova+brojBodova;
}

Kada ukupna vrednost bodova dostigne vrednost 30 ciklus će se prekinuti. Da bi brojali cikluse uvešćemo celobrojnu promenljivu čija je početna vrednost nula, a kada se svaki ciklus izbrši taj broj se poveća za 1;
int brojBodova;
int ukupnoBodova=0;
Scanner ucitavac=new Scanner(System.in);
int brojCiklusa=0;
while(ukupnoBodova < 30)
{
System.out.println("Unesite broj bodova");
brojBodova=ucitavac.nextInt();
ukupnoBodova=ukupnoBodova+brojBodova;
brojCiklusa ++;//Broj ciklusa se povećava za 1
}
​Na kraju ćemo se obezbediti da broj ciklusa maksimalno bude 10. To se može uraditi tako što se postojeći uslov
ukupnoBodova < 30
proširi sa dodatnim uslovom:
ukupnoBodova < 30 && brojCiklusa < 10
Ceo kod je sada dat na slici ispod:
import java.util.Scanner;

class Kviz {
public static void main(String[]args)
{
int brojBodova;
int ukupnoBodova=0;
Scanner ucitavac=new Scanner(System.in);
int brojCiklusa=0;
while(ukupnoBodova < 30 && brojCiklusa < 10)
{
System.out.println("Unesite broj bodova");
brojBodova=ucitavac.nextInt();
ukupnoBodova=ukupnoBodova+brojBodova;
brojCiklusa ++;//Broj ciklusa se povećava za 1
}
System.out.println("Ukupan broj bodova je "+ukupnoBodova);
}
}

 CIKLUS do-while sa uslovom na kraju  

Ova vrsta ciklusa je slična kao while ciklus, sa razlikom da se uslov postavlja na kraju ciklusa, a ne na početku:
do
{
NAREDBE
}
while(uslov_petlje);
DO WHILE petlja - algoritam
Slika 7: DO-WHILE petlja - algoritam
To praktično znači da kod do-while petlje niz naredbi mora odraditi bar jedanput, dok kod while ciklusa ne mora ni jedan put. Naredbe za ponavljanje se nalaze u petlji i ponavljaju se sve dok  postavljen uslov bude imao vrednost true.
​
Posmatrajmo sledeći primer:

PRIMER Temperatura:

Tekst zadatka: Učitati vrednosti temperature koja se očitava svaki sat na nekom mernom mestu.Učitavanje prekinuti kada se učita vrednost -100. Odrediti broj učitanih temperatura.
U ovom primeru se ne zna unapred koliko će biti potrebno ciklusa(broj očitanih temperatura), to je zapravo vrednost koju u ovom primeru treba odrediti. Ciklusi će uvom slučaju trajati dokle god bude ispunjen uslov da je učitana vrednost različita od -100 (Pretpostavka je da ovakva temperatura nije moguća, pa se ova vrednost koristi za prekid ciklusa).
U prvom delu zadatka definisaćemo promenljivu temperatura:
Scanner ucitavac=new Scanner(System.in);
double temperatura;
Unutar ciklusa, s obzirom da koristimo do-while petlju, izvršiće se najmanje jedno očitavanje temperature. Dalje očitavanje će zavisiti da li će biti učitana vrednost različita od -100. Ciklus bi dalje izgledao:
do
{
temperatura=ucitavac.nextDouble()
}
while(temperatura != -100);
 Ukoliko je prvo učitana vrednost -100 ostaće učitana samo prva vrednost temperature i ciklus se ne nastavlja dalje. Kompletan primer sada izgleda:

Broj učitanih temperatura jednak je broju ciklusa. Za određivanje broja ciklusa koristimo celobrojnu promenljivu brojCiklusa kao i u prethodnom primeru.
Zadaci kod kojih je pogodnije koristiti for ciklus jer unapred znamo broj ciklusa mogu se bez obzira na to rešiti i korišćenjem while ili do-while petlje. Primer sa izračunavanjem zbira niza prvih 10 prirodnih brojeva sa upotrebom while ciklusa bi izgledao:

Pošto u while petlji unutar male zagrade stoji samo uslov_petlje, inicijalizacija, koja je u for ciklusu takođe bila unutar male zagrade se ovde piše ispred ciklusa, dok se izraz_petlje u kome određujemo korak povećavanja kontrolne promenljive, piše kao jedna od naredbi unutar while ciklusa.

Ugnježdeni ciklusi(petlje)

Ugnježdene petlje, ali u programskom jeziku C/C++ možete pročitati na sledećoj strani: Ugnježdene petlje u C/C++
Ciklus se može naći i unutar nekog drugog ciklusa kao jedna od naredbi spoljašnjeg ciklusa:
for(inicijalizacija1; uslov_petlje1; izraz_petlje1)
{
for(inicijalizacija2; uslov_petlje2; izraz_petlje2)
{
niz_naredbi
}
}

Ugnježdene petlje primer 1:

Ugnježdene petlje omogućavaju izvršavanje petlji unutar drugih petlji. Na primer, for petlja može sadržavati još jednu for petlju, gde se unutrašnja petlja pokreće za svaki prolaz spoljašnje petlje. Ovo je korisno kod problema koji zahtevaju iteracije kroz višedimenzionalne strukture, poput matrica.
​
Primer:
for(int i = 0; i < 3; i++) {
    for(int j = 0; j < 3; j++) {
        System.out.println(i + ", " + j);
    }
}
​Ovo se može objasniti na sledećem primeru:

PRIMER Matrica:

Tekst zadatka: Ispisati matricu koja se sastoji od 10 redova i 10 kolona da izgleda kao na slici:
Matrica 10 x1 0 - izvršenje
Slika 8: Matrica 10 x1 0 - izvršenje

Rešenje:
​Da bi se ispisao jedan red brojeva koristimo for ciklus
for(int j = 0; i<=10; j++)
{
System.out.print((j+1)+" ");
}
Ovde se koristi vrednost(j+1) za ispisivanje prvog reda jer početna vrednost j nije 1 već 0.
Pošto treba ispisati još 9 takvih redova, treba ponoviti for naredbu još 9 puta. Mi ćemo dodati još jedan for ciklus(spoljašnji) tako da ovaj prethodni for ciklus bude naredba ugnježdena unutar  spoljašnjeg for ciklusa.
for(int i = 0; i<10; i++)
{
for(int j = 0; j<10; j++)
{
System.out.print((j+1)+” “);
}
}
System.out.println(); //Nov red

Kontrolna promenljiva i sada predstavlja tekući red, a kontrolna promenljiva j koja pripada unutrašnjoj petlji predstavlja indeks tekuće kolone. Ovaj kod treba malo izmeniti jer
System.out.print((j+1)+”  “);
ispisuje uvek brojeve 1 – 10, a trebalo bi recimo za i = 3 npr.(4. red) da ispisuje vrednosti za (i*10) veće u ovom slučaju za 30 veće( 31-40). To znači da naredbu treba izmeniti:
System.out.print(10 * i +(j+1)+”  “);


for-each petlja

for each petlje su uvedene sa JAVA 5 verzijom i upotrebljava se kada se koriste nizovi podataka i potrebno je prolaziti kroz elemente tog niza iterativno kroz cikluse. Npr ako bi smo definisali sledeći niz:
String [ ] planete={"Merkur","Venera","Zemlja","Mars","Jupiter","Saturn","Uran","Neptum","Pluton"};
Da bi ispisali prethodno definisan niz Stringova, koji predstavlja skup planeta u Sunčevom sistemu, pogodno je koristiti for-each petlju. Ovde je naredba takođe zapisana kao for, ali bez kontrolnih izraza, sa promenljivom "i". Umesto toga se koristi sledeća sintaksa:
for(String planeta:planete)
{
System.out.println(planeta);
}
planeta je ovde promenljiva istog tipa kao i elementi niza "planete". U svakom sledećem ciklusu vrednost promenljive planeta će biti element koji je  na sledećoj poziciji niza. Dakle, posle izvršenja prethodne naredbe na standardnom izlazu biće ispisano:
Merkur
Venera
Zemlja
...
Ovaj isti primer se mogao uraditi i sa običnom for petljom:
for(int i = 0; i < planete.length;i++)
{
System.out.println(planet[i]);
}
Ovaj primer je jednostavnije uraditi sa for-each petljom, ali postoje neki primeri koji ne mogu da se urade na taj način, već se mora koristiti obična for petlja. Npr. ako želimo da ispišemo niz celih brojeva unazad:
for(int i = 10; i > 0;i--)
{
System.out.println(i);
}
To bi na izlazu ispisalo sledeće:
10
9
8
...

for each petlje sa kolekcijama i nizovima objekata u Javi

for each petlja je pogodna za prolaz kroz kolekciju ili niz java objekata. Pretpostavimo da je u javi definisana sledeća kolekcija objekata(ArrayList):
ArrayList < Zaposleni > sviZaposleni = new ArrayList < >();
Lista predstavlja kolekciju objekata klase Zaposleni. Ako kreiramo 3 takva objekta i ubacimo ih u listu, onda bi smo za ispis podataka upotrebili for-each petlju, kao na sledećoj slici:
for-each petlja u javi-primer klase Preduzece
Slika 9: for-each petlja u javi-primer klase Preduzece
Klasa Zaposleni bi bila:
for-each petlja u javi-primer klase Zaposleni
Slika 10: for-each petlja u javi-primer klase Zaposleni
U novijim verzijama Jave foreach petlja može da se zapiše na sledeći način:
for-each petlja u javi-primer upotrebe ove petlje u verziji jave 8 ili više
Slika 11: for-each petlja u javi-primer upotrebe ove petlje u verziji jave 8 ili više

Optimizacija petlji

Optimizacija petlji uključuje smanjenje broja iteracija ili korišćenje efikasnijih algoritama kako bi se poboljšale performanse. Ključni saveti:
  • Izbegavaj nepotrebno računanje unutar petlje (npr. računaj konstantne vrednosti izvan petlje).
  • Koristi break kada je moguće da prekineš petlju ranije.
  • Uvek proveravaj uslove da bi se izbegle beskonačne petlje.
​

Primer optimizovane petlje:
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        break; // Prekida petlju kada je cilj pronađen
    }
}

Dodatni resursi

Povezani linkovi:
  • Kontrolne strukture u Javi: Istražite druge kontrolne strukture u Javi, kao što su if-else izjave i slučajevi prekidača, koji se često koriste zajedno sa petljama. Visit Control Structures Page
  • Rekurzije u Javi: Saznajte više o rekurziji, tehnici koja ponekad može da zameni petlje za određene zadatke, sa detaljnim primerima i objašnjenjima. Visit Recursion Page
  • Java Nizovi: Razumevanje nizova je neophodno kada radite sa petljama. Uronite u to kako nizovi funkcionišu i kako da iterirate kroz njih koristeći petlje. Visit Arrays in Java Page
2. Spoljni Resursi:
Primere iz petlji možete pronaći na veb stranici: Petlje - osnovni primeri
DODATNI PRIMERI​

​Priprema za kontrolni zadatak iz petlji

Srodni članci

Petlje u C++-primeri
Nizovi-primeri
Fibonačijev niz
Internet stvari
Grananje u programu - primeri
Algoritmi
Matrice
Java
Linkovi
​Politika Privatnosti
Kontakt

© 2021 by Slobodan svetprogramiranja.com

Sva prava zadržana
SVET PROGRAMIRANJA