Samarqand davlat universiteti raqamli texnologiyalar fakulteti optimal boshqaruv usullari kafedrasi

1. for — odatiy ko‘rinishi.
2. for-each — yangi formasi(ro‘yxatlar uchun).
Bu darsimizda, «for» operatorining odatiy ko‘rinishini o‘rganamiz.
Bu operator ham sikl yaratishda ishlatiladi va u quyidagi sintaksisga ega:
for (e’lon qilish;shart;qaytarilish) {
operatorlar bloki
}
Operatorning yaxshi tomoni shundaki, siklga oid barcha amallarni(elon qilish, shart, shartni o‘zgartirish) o‘z ichida bir qatorda yozish imkoni mavjudligidir.
Misol asosida tushuntirib o‘taman,

1 2 3 4 5 6 7

class test { public static void main(String args[ ]){ int a; for (a=8; a>0; a--) System.out.println("raqam " + a ) ; } }

«int» tipidagi «a» o‘zrauvchi e’lon qilindi va «for» operatori o‘z ishini boshladi. Dastlab, bir qatorda eng asosiy ishlar aniqlashtirib olindi: o‘zgaruvchiga qiymat berish, shart qo‘yish va o‘zgaruvchini qiymatini bittaga kamaytirish(shartni o‘zgartirish uchun). Shundan so‘ng, sikl tanasida «a» o‘zgaruvchini qiymati ekranga chiqarildi va sikl o‘z ishini tugatdi.

Bu sikl qanday ishlaydi? «a» o‘zgaruvchigi «8» qiymati o‘zlashtirildi va «a» o‘zgaruvchini musbatligi tekshirildi(a>0). Keyin, ekranga chiqarish operatori ishga tushdi(a— operatori tashlab ketiladi) va oxirida «a» o‘zgaruvchi qiymati bittaga kamaytiriladi. Siklning keyingi aylanishida, o‘zlashtirish operatori tashlab ketiladi, birdaniga shart rost yoki yolg‘onligi tekshiriladi, agar rost bo‘lsa, ekranga chiqarish operatori ishga tushadi va «a» qiymati bittaga kamaytiriladi. Bu hol, shart yolg‘on natija berguncha davom etadi, ya’ni a=0 bo‘lguncha.
Misoldan quyidagilarni ko‘rish mumkin:
— shartni boshqaruvchi o‘zgaruvchi bir marotaba e’lon qilinar ekan;
— shart tekshirilgandan so‘ng, darhol sikl tanasi ishga tushadi, so‘ng shartni boshqaruvchi o‘zgaruvchi o‘zgartiriladi;
— sikl tanasi shart tekshirilgandan so‘ng ishga tushadi, bu degani shart yolg‘on bo‘lsa, sikl tanasidagi operatorlar umuman ishlamasligi ham mumkin, ya’ni bu «sharti oldin tekshiriladigan» sikl ekan.

1 2 3 4 5 6 7

class test { public static void main(String args[ ]){ int n; for(n=10; n>20; n--) System.out.println("son " + n ); } }

Misolda, shart yolg‘on, shuning uchun sikl tanasi ishlamaydi va dastur hech nima qaytarmaydi.
Sikl shartini boshqaradigan o‘zgaruvchini, sikl ichida ham e’lon qilish mumkin,

1 2 3 4 5

class test { public static void main(String args[ ]){ for(int n=10; n>0; n--) System.out.println("son" + n ); }}

Bu holda, o‘zgaruvchi faqat siklga tegishli bo‘ladi va uni dasturning boshqa yerida ishlatib bo‘lmaydi. Barcha joyda ishlatish uchun, uni sikldan tashqarida e’lon qilish lozim.

Sikl ichida bir necha o‘zgaruvchilarni e’lon qilib, ularni shartda tekshirish mumkin.

1 2 3 4 5 6

class test { public static void main(String args[ ]){ int a, b; for(a=10, b=20; b>a; a++, b--) System.out.println("son " + a); }}

Ikkita o‘zgaruvchi e’lon qilinib, ular bir-biri bilan solishtirilmoqda va ularning qiymati o‘zgartirib borilmoqda, natija ularning kesishgan nuqtasi bo‘ladi.

«For» siklinin bir qancha qismlarini tushirib qoldirish mumkin.

1 2 3 4 5 6 7

class test { public static void main(String args[ ]){ int a=4; for(; a>0; a--) System.out.println("son " + a); } }

Bu misolda, o‘zgaruvchini e’lon qilish sikl tashqarisiga olib chiqilgan, bu qism siklda bo‘lmaganligi uchun, u nuqta-vergul (;) bilan almashtirilgan.

Navbatdagi misolni ko‘ramiz, bunda birato‘la ikkita qism sikldan(sikl bosh qismidan) chiqarilgan.

1 2 3 4 5 6 7

class test { public static void main(String args[ ]){ int a=3; for(; a>0;){ System.out.println("son " + a); a--; }}}

O‘zgaruvchini e’lon qilish sikl tashqarisiga, o‘zgaruvchini o‘zgartirish esa, sikl tanasiga o‘tkazilgan va ularningo‘rninuqta-vergul(;) bilanto‘ldirilgan.

Undan ham qizig‘i bor, siklning barcha qismlarini olib tashlaymiz(bu ishni amalga oshirmang(!), sababini keyingi qatorlarda yozaman.)

1 2 3 4 5 6 7 8

class test { public static void main(String args[ ]){ int a=10; for(;;){ System.out.println("son " + a); a--; }}}

Bu holda o‘zgaruvchi sikldan tashqarida e’lon qilinmoqda, bu o‘zgaruvchini o‘zgartirish sikl tanasida amalga oshirilmoqda, lekin shart yo‘q. Shu sababli bu sikl to‘xtamasdan ishlayveradi, ya’ni to‘xtovsiz sikl bo‘lib qoladi. Bu ishni bajarmang(!).
Oldingi maqolada, for sikl operatorini standart ko‘rinishini o‘rganib chiqgan edik. Endi, shu sikl operatorini boshqa ko‘rinishini(for-each) yozib o‘taman. Bu tip, juda ko‘p dasturlash tillarida ham mavjud bo‘lib, maqsadli ishlatish juda foydali hisoblanadi.
Shunday ekan, bu operator bilan tanishishni boshlaymiz va dastlab uning sintaksisini ko‘rib chiqamiz.
for (tip o‘zgaruvchi_e’lon_qilish: kolleksiya) {
operatorlar bloki;
}
Ko‘rib turganingizdek, kalit so‘z «for«, standart for ko‘rinishga ega.
Sintaksisdagi tip, bu o‘zgaruvchi tipi, o‘zgaruvchi esa, kolleksiyaning qiymatlarini ketma-ket o‘zida saqlovchi konteyner. Kolleksiya — bir xil tipdagi ma’lumotlar jamlanmasi hisoblanadi, misol uchun massiv. Tip va kolleksiya elementlarining tipi bir xil bo‘lishi lozim. Siklda har xil ko‘rinishdagi kolleksiyalar bo‘lishi mumkin. Maqolada kolleksiya sifatida massivlardan foydalanamiz, keyingi maqolada kolleksiyaning boshqa turini ham yozib o‘taman.
«For» va «For-each» operatorlarini farqini ko‘rsatish uchun, bitta misolni 2 xil usulda ko‘rsatib o‘taman(biri for, ikkinchisi for-each).
Massiv elementlarini qiymatini summasini hisoblovchi dastur tuzamiz.

1 2 3 4 5 6 7 8 9 10

class test { public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i=0; i<5; i++){ summa+=numb[i]; } System.out.println("Summa="+summa); } }

Dastlab, «int» tipida «numb» nomli 4 ta elementdan iborat(massiv 0 dan boshlanadi) massiv yaratildi va ularga qiymatlar berildi.
Agar massiv tushunchasi biroz esingizdan chiqgan bo‘lsa, quyidagi maqolani o‘qib oling.
Shundan so‘ng, «int» tipidagi «summa» nomli o‘zgaruvchi yaratilib, «0» qiymat berildi. Bu o‘zgaruvchi umumiy summani qiymatini o‘zida saqlaydi. Keyin, «for» sikli ochilib, massiv elementlari birin-ketin qo‘shilib, «summa» nomli o‘zgaruvchiga tashlab borildi va natijada barcha elementlar yig‘indisi hosil bo‘ldi.
Sikl ishlashi, dastlab «i» o‘zgaruvchiga «0» o‘zlashtirildi va shart tekshirildi, shart rost, shuning uchun sikl tanasi ishga tushdi. «numb[i]» — bu massivning «i»chi elementidir, ya’ni i=0 bo‘lsa, numb[0](massivning birinchi elementi), i=1 bo‘lsa, numb[1](massivning ikkinchi elementi) vahakazo. Shu tariqa massiv elementlari yig‘ildi.i=5 bo‘lganda, sikl sharti yolg‘on qiymatni qabul qildi va sikl ishlamay, dastur yakunlandi. So‘ng, umumiy yig‘indi(summa) ekranga chiqarildi.

Endi, yuqoridagi misolni «for-each» orqali ishlaymiz.

1 2 3 4 5 6 7 8 9 10

class test { public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i : numb){ summa+=i; } System.out.println("Summa="+summa); } }

Farq unchalik katta emas, biz faqat siklning boshlang‘ich(i=0) va oxirgi nuqtasini(i<5) ko‘rsatayotkanimiz yo‘q xolos, hammasi avtomat bajarildi. Dastlab, «i» o‘zgaruvchiga massivning birinchi elementi berildi va «summa» o‘zgaruvchiga qo‘shildi, keyin ikkinchi elementi vahakazo, qachonki massiv elementlari tugasa sikl ham to‘xtadi. Barcha massiv elementlari yig‘indisi «summa» o‘zgaruvchiga yig‘ilib, ekranga chiqarildi. Demak siklning qancha davom etishi kolleksiyaning uzunligiga bog‘liq bo‘lar ekan.
Bu usul kolleksiyalar bilan ishlashda qulaydir, bilmasdan yo‘l qo‘yiladigan xatoliklarni oldi olinadi. Agar siz kolleksiyalarda «for» operatorini ishlatsangiz va shartda, elementlarni noto‘g‘ri yozib yuborsangiz, xatolik haqida axborot olishingiz mumkin bo‘ladi. Misol,

1 2 3 4 5 6 7 8 9 10

class test{ public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i=0; i<10; i++){ summa+=numb[i]; } System.out.println("Summa="+summa); } }

Dasturda, shartga ko‘ra elementlar soni 10 ta qilib belgilanmoqda(i<10), bu esa xatolik, chunki massiv elementlari 4ta(massiv 0 dan boshlanadi), marhamat natijani ko‘ravering.

Agar «i» o‘zgaruvchi «0» dan emas biror boshqa sondan boshlansa, massivning ba’zi elementlarini tashlab ketib qolishingiz mumkin.

1 2 3 4 5 6 7 8 9 10

class test { public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i=2; i<5; i++){ summa+=numb[i]; } System.out.println("Summa="+summa); } }

Misolda, «i» o‘zgaruvchi «2» sonidan boshlanmoqda, bu degani massining 2 ta elementi(0 va 1) yig‘indisi qolib ketti.
«For-each» operatori yuqoridagi xatoliklarni oldini oladi, asosan kolleksiyalar bilan ishlashga moslashgan. Agar massivning biror elementigacha hisoblash kerak bo‘lsa, «break» operatori orqali sikldan chiqish mumkin bo‘ladi.

1 2 3 4 5 6 7 8 9 10 11

class test { public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i : numb){ summa+=i; if(i==3) break; } System.out.println("Summa="+summa); } }

Sikl ichida shart qo‘yildi, agar «i» o‘zgaruvchi 3 ga teng bo‘lsa, sikldan butunlay chiqib ket, ya’ni massivning qolgan element qiymatlarini qabul qilma. Natijada, massivning faqat 3 ta elementi(0, 1, 2 ya’ni 1+2+3) yig‘indisi hisoblandi.

«For-each«ning yana bir o‘ziga xosligi, undagi o‘zgaruvchini kod yordamida o‘zgartirib bo‘lmaydi.

1 2 3 4 5 6 7 8 9 10 11

class test { public static void main(String args[ ]){ int numb[ ]={1,2,3,4,5}; int summa=0; for(int i : numb){ summa+=i; i=20; } System.out.println("Summa="+summa); } }

Kodda, «i» o‘zgaruvchi qiymati o‘zgartirishga harakat qilindi(i=20), lekin siklda bu inobatga olinmadi. Natija ham o‘sha o‘sha.
O‘tish operatorlari, boshqaruvni, dasturning bir qismidan boshqa bir qismiga ko‘chirish uchun ishlatiladi. Java dasturlash tilida 3 xil o‘tish operatorilari mavjud: break, continue, return. «Break» operatori biror sikldan to‘liq chiqish uchun ishlatiladi, «continue» esa ishlayotgan sikl qadamini to‘xtatib, sikl boshiga o‘tadi va navbatdagi qadam bilan sikl ishlashini davom ettiradi. «Return» operatoridan biror-bir metoddan chiqish uchun foydalaniladi.
Oxirgi operatorni, keyingi maqolalarda ko‘ramiz.