Sikllar - Java dasturlash tili

Sikl - bir amalni ko'p marta takrorlash vositasi. Java'da to'rt xil sikl bor va har birining o'z o'rni bor.

Kengaytirilgan for #

To'plam bo'ylab yurishning eng qulay usuli:

Java

public class Har {
    public static void main(String[] args) {
        String[] shaharlar = {"Namangan", "Andijon", "Samarqand"};

        for (String shahar : shaharlar) {
            System.out.println("  " + shahar + " - "
                    + shahar.length() + " harf");
        }
    }
}

Natija

  Namangan - 8 harf
  Andijon - 7 harf
  Samarqand - 9 harf

Indeks bilan ovora bo'lish shart emas, chegaradan chiqib ketish mumkin emas. Ro'yxat bo'ylab yurish kerak bo'lsa - shu.

Oddiy for #

Java

public class Oddiy {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i + " ning kvadrati = " + (i * i));
        }
    }
}

Natija

1 ning kvadrati = 1
2 ning kvadrati = 4
3 ning kvadrati = 9
4 ning kvadrati = 16
5 ning kvadrati = 25

Qism	Misol	Qachon bajariladi
Boshlanish	`int i = 1`	Bir marta, boshida
Shart	`i <= 5`	Har takrordan oldin
Qadam	`i++`	Har takrordan keyin

Teskari yurish:

Java

public class Teskari {
    public static void main(String[] args) {
        String[] shaharlar = {"Namangan", "Andijon", "Samarqand"};

        for (int i = shaharlar.length - 1; i >= 0; i--) {
            System.out.println(i + ": " + shaharlar[i]);
        }
    }
}

Natija

2: Samarqand
1: Andijon
0: Namangan

Indeks noldan boshlanadi

shaharlar[0] - birinchi element, shaharlar[2] - uchinchi va oxirgisi.

Shuning uchun oxirgi indeks har doim length - 1. Eng ko'p uchraydigan xato - i <= length yozib qo'yish; u ArrayIndexOutOfBoundsException beradi.

Diqqat: massivda length maydon (qavssiz), satrda esa length() metod (qavs bilan). Bu Java'ning nomuvofiqliklaridan biri va uni shunchaki yodlash kerak.

while va do-while #

Java

public class Wh {
    public static void main(String[] args) {
        int son = 1000;
        int qadam = 0;

        while (son > 1) {
            son /= 2;
            qadam++;
        }

        System.out.println("1000 ni " + qadam
                + " marta ikkiga bo'lsak, 1 ga yetadi");
    }
}

Natija

1000 ni 9 marta ikkiga bo'lsak, 1 ga yetadi

do-while da shart oxirida tekshiriladi, shuning uchun tana kamida bir marta bajariladi:

Java

public class DoWhile {
    public static void main(String[] args) {
        int[] kiritilgan = {0, 0, 7};
        int indeks = 0;
        int qiymat;

        do {
            qiymat = kiritilgan[indeks];
            System.out.println("Tekshirilmoqda: " + qiymat);
            indeks++;
        } while (qiymat == 0 && indeks < kiritilgan.length);

        System.out.println("Nolga teng bo'lmagan qiymat: " + qiymat);
    }
}

Natija

Tekshirilmoqda: 0
Tekshirilmoqda: 0
Tekshirilmoqda: 7
Nolga teng bo'lmagan qiymat: 7

break va continue #

Java

public class Boshqaruv {
    public static void main(String[] args) {
        int[] sonlar = {3, 8, 15, 4, 22, 7};

        System.out.println("Juft sonlar:");
        for (int son : sonlar) {
            if (son % 2 != 0) {
                continue;
            }
            System.out.println("  " + son);
        }

        System.out.println("10 dan katta birinchi son:");
        for (int son : sonlar) {
            if (son > 10) {
                System.out.println("  " + son);
                break;
            }
        }
    }
}

Natija

Juft sonlar:
  8
  4
  22
10 dan katta birinchi son:
  15

Belgili sikl #

Ichma-ich sikldan birdaniga chiqish kerak bo'lganda:

Java

public class Belgili {
    public static void main(String[] args) {
        int[][] jadval = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
        };

        tashqi:
        for (int i = 0; i < jadval.length; i++) {
            for (int j = 0; j < jadval[i].length; j++) {
                if (jadval[i][j] == 5) {
                    System.out.println("Topildi: [" + i + "][" + j + "]");
                    break tashqi;
                }
            }
        }

        System.out.println("Sikldan chiqildi");
    }
}

Natija

Topildi: [1][1]
Sikldan chiqildi

Oddiy break faqat ichki sikldan chiqardi. break tashqi ikkalasini ham to'xtatadi.

Belgili sikl kamdan-kam kerak

U foydali vosita, lekin kod o'qishni qiyinlashtiradi. Ko'p hollarda yaxshiroq yechim bor: ichma-ich siklni alohida metodga ajratib, return bilan chiqish.

Java

public class Metodda {
    public static void main(String[] args) {
        int[][] jadval = {{1, 2}, {3, 4}};
        System.out.println(Qidir(jadval, 4));
        System.out.println(Qidir(jadval, 9));
    }

    static String Qidir(int[][] jadval, int kerak) {
        for (int i = 0; i < jadval.length; i++) {
            for (int j = 0; j < jadval[i].length; j++) {
                if (jadval[i][j] == kerak) {
                    return kerak + " -> [" + i + "][" + j + "]";
                }
            }
        }
        return kerak + " topilmadi";
    }
}

Natija

4 -> [1][1]
9 topilmadi

Bu variant qisqaroq va nima qilayotgani nomidan ko'rinib turadi.

Ichma-ich sikllar #

Java

public class Jadval {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                System.out.printf("%4d", i * j);
            }
            System.out.println();
        }
    }
}

Natija

   1   2   3
   2   4   6
   3   6   9

Ichma-ich sikl narxi

Tashqi sikl n marta, ichkisi m marta aylansa, tana n * m marta bajariladi.

Uchga uch - to'qqiz marta, muammo yo'q. Lekin ikkalasi ham 10 000 marta aylansa, bu 100 million amal degani.

Ichma-ich sikl yozayotganingizda har doim "eng katta holatda necha marta aylanadi?" deb o'zingizdan so'rang.

Kolleksiyani sikl ichida o'zgartirish #

Java

import java.util.*;

public class Ozgartirish {
    public static void main(String[] args) {
        List<Integer> sonlar = new ArrayList<>(List.of(1, 2, 3, 4));

        try {
            for (Integer son : sonlar) {
                if (son == 2) {
                    sonlar.remove(son);
                }
            }
        } catch (ConcurrentModificationException x) {
            System.out.println("Istisno: " + x.getClass().getSimpleName());
        }

        System.out.println("Ro'yxat hali ham: " + sonlar);
    }
}

Natija

Istisno: ConcurrentModificationException
Ro'yxat hali ham: [1, 3, 4]

Bu tuzoq juda xavfli

Diqqat qiling: element o'chirildi, lekin keyin istisno tashlandi. Ya'ni kolleksiya yarim o'zgargan holatda qoldi.

Nomi chalg'ituvchi: ConcurrentModificationException ko'p oqim bilan bog'liq emas. U bitta oqimda ham yuzaga keladi - sikl kolleksiyani o'qiyotganda uning o'zgarganini sezadi.

Uchta to'g'ri yechim:

Java

import java.util.*;

public class Yechim {
    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>(List.of(1, 2, 3, 4));
        a.removeIf(s -> s == 2);
        System.out.println("removeIf:  " + a);

        List<Integer> b = new ArrayList<>(List.of(1, 2, 3, 4));
        Iterator<Integer> it = b.iterator();
        while (it.hasNext()) {
            if (it.next() == 2) {
                it.remove();
            }
        }
        System.out.println("Iterator:  " + b);

        List<Integer> c = new ArrayList<>(List.of(1, 2, 3, 4));
        for (int i = c.size() - 1; i >= 0; i--) {
            if (c.get(i) == 2) {
                c.remove(i);
            }
        }
        System.out.println("Teskari:   " + c);
    }
}

Natija

removeIf:  [1, 3, 4]
Iterator:  [1, 3, 4]
Teskari:   [1, 3, 4]

Eng qisqasi va eng o'qish osoni - removeIf.

Cheksiz sikl #

Java

public class Cheksiz {
    public static void main(String[] args) {
        int son = 0;

        while (true) {
            son++;
            if (son >= 3) {
                break;
            }
        }

        System.out.println("Sikl " + son + " da to'xtadi");
    }
}

Natija

Sikl 3 da to'xtadi

while (true) ataylab cheksiz sikl yaratadi va undan break bilan chiqiladi - masalan menyu ko'rsatadigan dasturda.

Tasodifiy cheksiz sikl

Eng ko'p uchraydigan sabab - hisoblagichni oshirishni unutish:

Java

int i = 0;
while (i < 10) {
    System.out.println(i);
    // i++ unutilgan - sikl hech qachon tugamaydi
}

Dastur qotib qoladi va uni Ctrl + C bilan to'xtatish kerak bo'ladi.

Sikl yozgach, o'zingizdan so'rang: "shart qachon false bo'ladi?" Javob topolmasangiz, sikl cheksiz.

Qaysi siklni tanlash #

Vaziyat	Sikl
To'plamdagi har bir element	Kengaytirilgan `for`
Indeks kerak yoki qadam 1 emas	Oddiy `for`
Teskari yurish yoki element o'chirish	Oddiy `for` yoki `removeIf`
Takror soni oldindan noma'lum	`while`
Kamida bir marta bajarilishi shart	`do-while`

Amaliy topshiriq

Kengaytirilgan for bilan massiv elementlarini chiqaring.
Oddiy for bilan 1 dan 10 gacha kvadratlarni chiqaring.
Massivni teskari tartibda chiqaring.
while bilan sonni necha marta 2 ga bo'lish mumkinligini hisoblang.
continue bilan faqat toq sonlarni chiqaring.
break bilan 100 dan katta birinchi sonni toping.
Belgili sikl bilan ikki o'lchovli massivdan qiymat qidiring.
Xuddi shuni alohida metod va return bilan qayta yozing.
Sikl ichida ro'yxatdan element o'chirib, istisnoni ko'ring.
Uni removeIf bilan to'g'rilang.

Xulosa #

Kengaytirilgan for - to'plam bo'ylab yurishning eng xavfsiz usuli.
Massivda length maydon, satrda length() metod.
Oxirgi indeks har doim length - 1.
continue joriy takrorni o'tkazadi, break siklni to'xtatadi.
Belgili break ichma-ich sikldan birdan chiqaradi, lekin ko'pincha alohida metod + return yaxshiroq.
Ichma-ich sikl narxi ko'paytiriladi - n * m.
Sikl ichida kolleksiyani o'zgartirish ConcurrentModificationException beradi - removeIf ishlating.
Sikl yozgach so'rang: "shart qachon false bo'ladi?"

Keyingi bo'limda massivlarni o'rganamiz.

Kengaytirilgan for #

Oddiy for #

while va do-while #

break va continue #

Belgili sikl #

Ichma-ich sikllar #

Kolleksiyani sikl ichida o'zgartirish #

Cheksiz sikl #

Qaysi siklni tanlash #

Xulosa #

Xatolik topdingizmi?