Kitaran ialah serpihan program yang berulang berkali-kali.

Terdapat dua jenis gelung dalam java: jenis "while" dan jenis "n-time".

Jenis pertama "sementara" direka untuk mengulangi beberapa tindakan selagi beberapa syarat dipenuhi. Contoh: menambah nombor sebanyak 5 sehingga mencapai tiga digit.

Jenis kedua "n-time" bertujuan untuk mengulangi beberapa tindakan dalam beberapa kali yang telah ditetapkan. Contoh: mendarab nombor dengan sendiri sebanyak 4 kali.

Gelung while (kenyataan semasa dan lakukan...sementara)

Pernyataan while mengulangi tindakan yang ditentukan selagi parameternya adalah benar.

Sebagai contoh, gelung sedemikian akan dilaksanakan 4 kali dan "1 2 3 4" akan dipaparkan pada skrin:

Int i = 1; Sementara saya< 5) { System.out.print(i + " "); i++; }

Gelung sedemikian tidak akan dilaksanakan sekali pun dan tiada apa yang akan dipaparkan pada skrin:

Int i = 1; Sementara saya< 0) { System.out.print(i + " "); i++; }

Gelung ini akan berjalan tanpa henti dan skrin akan memaparkan "1 2 3 4 5 6 7...":

Int i = 1; manakala (benar) ( ​​System.out.print(i + " "); i++; )

Keadaan yang menentukan sama ada gelung akan diulang semula disemak sebelum setiap langkah gelung, termasuk yang pertama. Mereka berkata apa yang berlaku pra-semak syarat.

Terdapat kitaran seperti "bye" dengan semakan selepas syarat. Untuk menulisnya, binaan do...while statement digunakan.

Gelung ini akan dilaksanakan 4 kali dan "2 3 4 5" akan dipaparkan pada skrin:

< 5);

Gelung ini akan dilaksanakan 1 kali, dan "2" akan dipaparkan pada skrin:

Int i = 1; lakukan ( i++; System.out.print(i + " "); ) manakala (i< 0);

Badan do...while loop dilaksanakan sekurang-kurangnya sekali. Operator ini mudah digunakan apabila beberapa tindakan dalam program perlu dilakukan sekurang-kurangnya sekali, tetapi dalam keadaan tertentu ia perlu diulang berkali-kali.

Semak atur cara berikut (ia meneka integer rawak daripada segmen dan meminta pengguna menekanya dengan memasukkan pilihan dari papan kekunci, sehingga pengguna meneka nombor itu, program akan menggesanya, memberitahunya sama ada nombor yang diteka lebih banyak atau kurang daripada yang dimasukkan pengguna):

Import java.util.Scanner; kelas awam Utama ( public static void main(String args) ( // prog - nombor yang dicipta oleh program // pengguna - nombor yang dimasukkan oleh pengguna int prog, pengguna; // Hasilkan integer rawak dari 1 hingga 10 prog = (int)(Math. rawak() * 10) + 1; System.out.println("Saya fikir nombor dari 1 hingga 10, teka."); System.out.print("Masukkan nombor anda: " ); Input pengimbas = Pengimbas baharu( System.in); // Semak sama ada terdapat integer dalam aliran input if(input.hasNextInt()) ( lakukan ( // Baca integer daripada pengguna aliran input = input.nextInt (); if(user == prog) ( System.out.println("Anda telah menekanya!"); ) else ( // Semak sama ada nombor itu disertakan dalam segmen jika (pengguna > 0 && pengguna<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Buat pengubahsuaian berikut pada program:

Program harus memikirkan nombor bukan daripada segmen , tetapi integer daripada segmen daripada [−10;10], tidak termasuk sifar. Pada masa yang sama, cuba pastikan bahawa pengagihan nombor rawak yang dijana oleh program adalah seragam (iaitu, jika sifar jatuh, ia tidak boleh digantikan dengan beberapa nombor lain, contohnya, dengan 1, kerana kemudian 1 akan menjadi. jatuh dengan kebarangkalian dua kali lebih banyak daripada nombor yang lain).

Program ini harus menggesa pengguna bahawa dia membuat kesilapan dalam tanda jika program meneka nombor positif dan pengguna memasukkan nombor negatif. Dan begitu juga sebaliknya.

Gelung masa N (untuk pernyataan)

Pernyataan for mengandungi tiga parameter. Yang pertama dipanggil inisialisasi, yang kedua dipanggil keadaan pengulangan, dan yang ketiga dipanggil lelaran.

Untuk (permulaan; keadaan; lelaran) ( // badan gelung, iaitu tindakan diulang secara kitaran)

Dalam parameter pertama, anda biasanya memilih beberapa pembolehubah yang akan digunakan untuk mengira bilangan ulangan gelung. Ia dipanggil kaunter. Kaunter diberi beberapa nilai awal (mereka menunjukkan dari nilai apa yang akan berubah).

Parameter kedua menunjukkan beberapa had pada kaunter (tunjukkan kepada nilai yang akan berubah).

Parameter ketiga menentukan ungkapan yang mengubah pembilang selepas setiap langkah gelung. Biasanya ini ialah kenaikan atau pengurangan, tetapi anda boleh menggunakan sebarang ungkapan di mana kaunter akan diberikan beberapa nilai baharu.

Sebelum langkah pertama gelung, kaunter diberikan nilai awal (penginisiatifan dilakukan). Ini hanya berlaku sekali sahaja.

Sebelum setiap langkah gelung (tetapi selepas permulaan), keadaan pengulangan diperiksa; jika ia benar, maka badan gelung dilaksanakan semula. Pada masa yang sama, badan gelung tidak boleh dilaksanakan walaupun sekali jika syarat itu palsu pada masa semakan pertama.

Selepas melengkapkan setiap langkah gelung dan sebelum memulakan langkah seterusnya (dan oleh itu sebelum menyemak keadaan pengulangan), lelaran dilakukan.

Program berikut memaparkan nombor dari 1 hingga 100:

Untuk (int i = 1; i<= 100; i++) { System.out.print(i + " "); }

Program berikut memaparkan nombor dari 10 hingga -10:

Untuk (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Program yang dibentangkan memaparkan nombor ganjil dari 1 hingga 33:

Untuk (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }

Atur cara yang dibentangkan akan mengira jumlah unsur-unsur serpihan urutan 2, 4, 6, 8,... 98, 100. Jadi:

Jumlah int = 0; // Kami akan mengumpul hasil di sini untuk (int j = 2; j

Program yang dibentangkan akan menaikkan nombor daripada pembolehubah a kepada darjah semula jadi daripada pembolehubah n:

Ganda a = 2; int n = 10; gandaan semula = 1; // Kami akan mengumpul hasil di sini untuk (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Program yang dibentangkan akan memaparkan 10 elemen pertama bagi jujukan 2n+2, di mana n=1, 2, 3…:

Untuk (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }

Program yang dibentangkan akan memaparkan 10 elemen pertama bagi urutan 2a n−1 +3, di mana a 1 =3:

Int a = 3; untuk (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

Dalam satu kitaran, anda boleh menetapkan beberapa pembilang sekaligus. Dalam kes ini, beberapa ungkapan dalam lelaran dan dalam permulaan dipisahkan dengan koma. Hanya satu syarat pengulangan boleh ditentukan, tetapi ia boleh menjadi ungkapan yang mengandungi beberapa pembilang sekaligus.

Program yang dibentangkan akan memaparkan 10 elemen pertama bagi urutan 2a n−1 -2, di mana a 1 =3:

Untuk (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Program yang dibentangkan akan memaparkan urutan berikut "0 -1 -4 -9 -16 -25":

Untuk (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Menamatkan gelung lebih awal (pernyataan putus)

Kedua-dua gelung jenis "semasa" dan gelung jenis "n-masa" boleh ditamatkan lebih awal jika anda memanggil operator di dalam badan gelung rehat. Dalam kes ini, gelung akan keluar serta-merta; malah langkah semasa tidak akan selesai (iaitu, jika terdapat sebarang kenyataan lain selepas rehat, ia tidak akan dilaksanakan).

Hasil daripada contoh berikut, hanya nombor “1 2 3 4 Tamat” akan dipaparkan pada skrin:

Untuk (int a=1; a

Apabila atur cara melaksanakan gelung untuk kali kelima (masuk gelung dengan pembilang sama dengan 5), keadaan di mana penyataan putus akan dilaksanakan akan segera diperiksa dan didapati benar. Baki bahagian badan gelung (output ke skrin) tidak akan dihasilkan: program akan terus melaksanakan operasi yang ditentukan selepas gelung dan seterusnya.

Menggunakan pernyataan putus, anda boleh mengganggu gelung yang jelas tidak terhingga. Contoh (skrin akan memaparkan "100 50 25 12 6 3 1 0" dan selepas itu gelung akan berhenti):

Int s = 100; manakala (benar) ( ​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Adalah wajar untuk memanggil operator pemecahan hanya apabila beberapa keadaan berlaku, jika tidak gelung akan disiapkan lebih awal daripada jadual pada langkah pertamanya.

Int a; untuk (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Dalam contoh di atas, output ke skrin dalam gelung tidak akan berlaku walaupun sekali, dan apabila pembolehubah a dipaparkan pada skrin selepas gelung, ternyata nilainya tidak pernah berubah, iaitu "a=25" akan dipaparkan (dan tidak lebih).

Perhatikan juga bahawa pembolehubah telah diisytiharkan sebelum gelung bermula. Apabila pembolehubah diisytiharkan dalam parameter gelung, ia ternyata tidak boleh diakses di luarnya, tetapi dalam kes ini sesuatu yang lain diperlukan - untuk mengetahui nilai yang akan ada pada kaunter selepas gelung berakhir.

Tugasan

Buat program yang memaparkan semua nombor empat digit dalam urutan 1000 1003 1006 1009 1012 1015….

Tulis atur cara yang memaparkan 55 elemen pertama jujukan 1 3 5 7 9 11 13 15 17 ….

Tulis program yang memaparkan semua unsur bukan negatif bagi jujukan 90 85 80 75 70 65 60 ….

Tulis atur cara yang memaparkan 20 elemen pertama jujukan 2 4 8 16 32 64 128 ….

Paparkan semua sebutan bagi jujukan 2a n-1 -1, dengan a 1 =2, iaitu kurang daripada 10000.

Paparkan semua sebutan dua digit bagi jujukan 2a n-1 +200, dengan a 1 = -166.

Cipta atur cara yang mengira pemfaktoran nombor asli n yang pengguna masukkan daripada papan kekunci.

Paparkan semua pembahagi positif nombor asli yang dimasukkan oleh pengguna daripada papan kekunci.

Semak sama ada nombor asli yang dimasukkan oleh pengguna daripada papan kekunci adalah perdana. Cuba untuk tidak melakukan tindakan yang tidak perlu (contohnya, selepas anda menemui sekurang-kurangnya satu pembahagi bukan remeh, sudah jelas bahawa nombor itu adalah komposit dan tidak perlu meneruskan pemeriksaan). Juga ambil perhatian bahawa pembahagi terkecil bagi nombor asli n, jika ia wujud sama sekali, mesti terletak dalam segmen.

Tulis satu atur cara yang memaparkan 12 elemen pertama bagi jujukan 2a n-2 -2, dengan a 1 =3 dan a 2 =2.

Paparkan 11 sebutan pertama bagi jujukan Fibonacci. Kami mengingatkan anda bahawa sebutan pertama dan kedua bagi jujukan adalah sama dengan sebutan, dan setiap sebutan seterusnya ialah hasil tambah dua sebelumnya.

Untuk nombor asli yang dimasukkan oleh pengguna dari papan kekunci, hitung jumlah semua digitnya (tidak diketahui terlebih dahulu berapa banyak digit dalam nombor itu).

Di bandar N, perjalanan trem dijalankan menggunakan tiket kertas koyak. Setiap minggu, depoh trem memesan segulung tiket dari pusat percetakan tempatan dengan nombor dari 000001 hingga 999999. Tiket dianggap "bertuah" jika jumlah tiga digit pertama nombor itu sama dengan jumlah tiga terakhir digit, sebagai contoh, dalam tiket dengan nombor 003102 atau 567576. Depoh trem memutuskan untuk memberikan cenderahati kepada pemenang setiap tiket bertuah dan kini tertanya-tanya berapa banyak cenderahati yang diperlukan. Menggunakan program ini, kira berapa banyak tiket bertuah dalam satu gulungan?

Di bandar N terdapat sebuah gudang besar di mana terdapat 50,000 rak yang berbeza. Untuk kemudahan pekerja, pengurusan gudang memutuskan untuk memesan plat dengan nombor dari 00001 hingga 50000 untuk setiap rak dari rumah percetakan tempatan, tetapi apabila plat dicetak, ternyata mesin cetak itu, disebabkan oleh kerosakan, tidak mencetak nombor 2, jadi semua plat yang nombornya mengandungi satu atau lebih dua (contohnya, 00002 atau 20202) - anda perlu menaipnya semula. Tulis program yang akan mengira bilangan plat yang salah ini berada dalam kelompok yang rosak.

Jam elektronik memaparkan masa dalam format dari 00:00 hingga 23:59. Kira berapa kali sehari ia berlaku bahawa gabungan simetri ditunjukkan di sebelah kiri kolon untuk yang di sebelah kanan kolon (contohnya, 02:20, 11:11 atau 15:51).

Dalam tentera Amerika, nombor 13 dianggap malang, dan dalam Jepun - 4. Sebelum latihan antarabangsa, ibu pejabat tentera Rusia memutuskan untuk mengecualikan bilangan peralatan ketenteraan yang mengandungi nombor 4 atau 13 (contohnya, 40123, 13313, 12345 atau 13040) supaya tidak mengelirukan rakan sekerja asing. Jika tentera mempunyai 100 ribu unit peralatan ketenteraan yang boleh digunakan dan setiap kenderaan tempur mempunyai nombor dari 00001 hingga 99999, maka berapakah bilangan yang perlu dikecualikan?

2010, Alexey Nikolaevich Kostin. Jabatan TIDM, Fakulti Matematik, Universiti Pedagogi Negeri Moscow.

Java, seperti hampir mana-mana bahasa pengaturcaraan, mempunyai alat untuk memastikan bahawa sekeping kod tertentu diulang berkali-kali, atau gelung, seperti yang biasa dipanggil. Gelung di Jawa diwakili oleh pernyataan seperti untuk dan sementara, serta variasinya. Biasanya, gelung digunakan untuk melintasi tatasusunan satu dimensi dan pelbagai dimensi serta struktur data boleh lelar (termasuk koleksi) untuk mencari elemen tertentu dan seterusnya beroperasi padanya. Walau bagaimanapun, ini bukan satu-satunya cara untuk menggunakan alat seperti gelung Java. Contoh penggunaan akan diberikan semasa ia disemak.

Java: penerangan dan contoh

Pengendali gelung asas dalam Java ialah while. Serpihan kod yang disertakan dalam badannya akan diulang sehingga keadaan ungkapan yang disertakan dalam kurungan selepas ia memenuhi nilai logik kebenaran. Bentuk umum pernyataan while adalah seperti berikut:

sementara(syarat) (

//badan gelung

Sebaik sahaja nilai keadaan logik tidak lagi benar, kod yang disertakan dalam badan gelung akan berhenti melaksanakan dan kawalan akan dipindahkan ke baris serta-merta mengikutinya.

Jika badan gelung mengandungi hanya satu pernyataan, maka pendakap kerinting boleh ditinggalkan, tetapi ia dianggap bentuk yang baik jika ia sentiasa ada. Rajah di atas menunjukkan gambarajah blok operasi operator ini.

Untuk kejelasan, mari kita lihat contoh yang dibentangkan dalam rajah di bawah:

Kiraan pembolehubah yang diisytiharkan pada mulanya mempunyai nilai 1. Seterusnya kita melihat ungkapan logik yang disertakan dalam kurungan selepas nama operator. Ia akan menjadi benar, i.e. kembalikan benar selagi nilai pembolehubah kiraan adalah kurang daripada atau sama dengan 10. Dalam badan gelung, dengan setiap pas (lelaran), nilai pembolehubah dinaikkan sebanyak 1 dan dipaparkan pada skrin konsol. Perhatikan bahawa apabila pembolehubah mencapai 11, gelung berhenti berjalan.

Jika nilai pembolehubah kiraan pada mulanya sama dengan 11, maka keadaan gelung adalah palsu, dan program itu tidak akan memasuki badannya.

Perlu diingat bahawa sintaks Java membolehkan anda menggunakan pernyataan sementara tanpa badan. Mari kita beri contoh. Katakan kita mempunyai dua pembolehubah i = 100 dan j = 200, kita berhadapan dengan tugas mengira secara pemrograman min aritmetik mereka - untuk ini kita boleh menggunakan "hollow" sambil:

manakala(++i< --j);

Akibatnya, nilai mana-mana dua pembolehubah akan sama dengan purata nilai asalnya. Seperti yang anda lihat, gelung berfungsi dengan sempurna tanpa badan dan melakukan semua tindakan yang diperlukan dalam ungkapan bersyarat.

gelung do-while

Dalam contoh sebelumnya, jika ungkapan bersyarat pada mulanya dikembalikan palsu, maka pelaksanaan program akan mengabaikan badan gelung dan meneruskan. Walau bagaimanapun, situasi sering timbul di mana pelaksanaan kod yang terkandung dalam badan gelung diperlukan sekurang-kurangnya sekali, tanpa mengira kebenaran ungkapan bersyarat. Dalam erti kata lain, ia berlaku bahawa menyemak kebenaran ungkapan bersyarat diperlukan bukan pada permulaan, tetapi pada akhir gelung. Variasi gelung while yang dipanggil do-while boleh menyediakan fungsi ini. Ia mempunyai bentuk berikut:

buat (
//badan gelung

) manakala(keadaan);

Seperti yang dapat kita lihat, pertama badan gelung dilaksanakan, dan hanya kemudian kebenaran keadaan diperiksa - dan seterusnya setiap lelaran.

Kod di atas akan berfungsi dengan cara yang sama seperti pada masa biasa. Walau bagaimanapun, jika kita menetapkan kiraan kepada 11, badan gelung masih akan dilaksanakan sekali sebelum pernyataan itu dapat menguji kebenaran ungkapan tersebut.

Penerangan dan contoh untuk - gelung Java

Mewakili bentuk bahasa yang universal dan cekap di Jawa. Sebelum versi kelima Java SDK, hanya terdapat satu bentuk tradisional bagi pengendali, dan selepas itu yang baharu muncul - untuk setiap satu. Dalam bahagian ini kita akan melihat bentuk tradisional pengendali. untuk Java gelung kelihatan seperti ini:

Sebelum kawalan dipindahkan ke kod dalam badan gelung, pembolehubah i, yang bertindak sebagai pembilang, mula-mula dimulakan. Seterusnya, ungkapan bersyarat disemak yang membandingkan pembilang dengan nilai tertentu, dan jika ia kembali benar, badan gelung dilaksanakan. Kemudian nilai pembilang ditukar dengan langkah yang telah ditetapkan dan ungkapan bersyarat disemak semula, dan seterusnya sehingga syarat menjadi palsu. Carta alir di bawah menggambarkan semua peringkat kitaran.

Untuk pemahaman yang lebih baik, berikut ialah contoh cara Java for loop berfungsi:

Kami melihat bahawa pembolehubah loopVal digunakan sebagai pembilang. Selepas setiap lelaran gelung, nilainya akan meningkat sebanyak 1, dan ini akan berterusan sehingga mencapai 11. Ambil perhatian bahawa pembolehubah kawalan boleh diisytiharkan di luar pernyataan for, tetapi jika anda tidak berhasrat untuk menggunakan pembolehubah ini di mana-mana selain daripada dalam gelung, adalah disyorkan untuk mengisytiharkannya secara langsung dalam penyata. Perlu diingat bahawa pembolehubah yang diisytiharkan dalam pernyataan itu sendiri mempunyai skop dalam gelung yang sama.

Terdapat situasi apabila anda perlu mengisytiharkan beberapa pembolehubah kawalan gelung. Untuk Java, gelung membenarkan anda untuk menentukan dua atau lebih pembolehubah yang dipisahkan dengan koma, dan melakukan ini semasa permulaan dan semasa lelaran. Pengendali sedemikian akan kelihatan seperti ini:

untuk(int i = 1, int j = 10; i< j; ++i, --j) {}

Dengan setiap lelaran, nilai pembolehubah i akan meningkat sebanyak 1, dan nilai pembolehubah j akan berkurangan sebanyak 1. Lelaran akan dilakukan sehingga i menjadi lebih besar daripada atau sama dengan j.

Ciri-ciri menggunakan untuk operator

Gelung for ialah reka bentuk yang agak fleksibel kerana ketiga-tiga bahagiannya (permulaan, keadaan dan kenaikan/penurunan) boleh digunakan untuk tujuan lain. Sebagai contoh, bukannya ungkapan bersyarat dengan pembolehubah kawalan, anda boleh menggantikan sebarang pembolehubah logik.

keluar boolean = palsu;

untuk (int i = 0; !keluar; ++i) (

Dalam contoh di atas, kita boleh memerhatikan bagaimana operasi gelung adalah bebas sepenuhnya daripada pembolehubah kawalan i dan bilangan lelaran bergantung semata-mata pada saat pembolehubah keluar menjadi benar. Selain itu, pembolehubah kawalan boleh dialih keluar sepenuhnya daripada gelung dan ini tidak akan menjejaskan operasinya dalam apa jua cara: for(; !exit;) (). Walaupun ini bukan cara paling bijak untuk memprogramkan, ia kadangkala berguna. Perkara utama adalah untuk menyediakan situasi di mana pembolehubah akan mengambil nilai yang diperlukan untuk keluar dari gelung, supaya tidak mengubahnya menjadi satu yang tidak terhingga.

Untuk Java, gelung juga boleh diisytiharkan dengan cara ini: for(; ;) (). Ini ialah contoh biasa bagi gelung tak terhingga dengan keadaan gangguan khas. Kami akan bercakap tentang cara untuk mengganggu kitaran jenis ini sedikit kemudian.

Untuk setiap gelung gaya

Gelung foreach Java sentiasa digunakan untuk mengulang secara berurutan melalui elemen tatasusunan atau mana-mana yang lain dan melakukan operasi berulang tertentu padanya. Contoh bentuk pernyataan for ini ditunjukkan di bawah:

Nama diisytiharkan sebagai pembolehubah berulang, dan tatasusunan rentetan nama yang diisytiharkan sebelum ini bertindak sebagai hujah kedua pengendali. Nama pembolehubah akan mengambil nilai setiap elemen tatasusunan secara bergilir-gilir sehingga semua elemennya telah diambil. Perlu diingatkan bahawa jenis pembolehubah mestilah serasi dengan jenis elemen yang disimpan dalam tatasusunan. Selain itu, pembolehubah nama adalah baca sahaja dan cuba mengubahnya tidak akan mengubah elemen dalam tatasusunan itu sendiri.

Penyataan gangguan gelung

Terdapat tiga penyataan gangguan gelung: putus, kembali dan teruskan. Dua yang pertama mampu mengganggu sepenuhnya gelung, manakala teruskan hanya mengganggu lelaran semasa. Jika anda menggunakan gelung tak terhingga sengaja dalam Java dalam kod anda, pengendali ini mesti ada di dalamnya. Mari lihat contoh mudah menggunakan break:

Walaupun untuk pernyataan ini mempunyai 11 lelaran, hanya 8 akan dilaksanakan, kerana apabila kiraan i bersamaan dengan 7, syarat yang mengandungi pernyataan pecah akan dicetuskan.

Pernyataan pulangan berfungsi dengan cara yang sama, dengan perbezaan bahawa ia bukan sahaja menyediakan keluar dari gelung Java, tetapi juga dari kaedah di mana gelung diletakkan.

Menggunakan rehat sebagai goto

Perlu diingat bahawa rehat hanya mengganggu gelung dalam badan yang terletak secara langsung, i.e. jika anda menggunakannya dalam gelung bersarang, gelung luar tidak akan berhenti berjalan. Untuk melakukan ini, pernyataan rehat boleh digunakan sebagai bentuk goto yang beradab.

Dalam versi ini, pengendali ini digunakan bersama dengan label, yang membolehkan anda mengatur keluar bukan sahaja dari gelung, tetapi juga dari mana-mana blok kod. Label ialah pengecam dinamakan yang sesuai diikuti dengan titik bertindih. Label diisytiharkan pada permulaan blok kod yang ditanda. Untuk mengganggu pelaksanaan blok yang ditanda, anda mesti mengisytiharkan di tempat yang betul: break label_name. Pertimbangkan contoh dalam rajah di bawah:

Kod tersebut mengisytiharkan tiga blok dengan nama label masing-masing Satu, Dua dan Tiga. Pernyataan putus berlabel Dua bersarang dalam ketiga-tiga blok, tetapi apabila ia menyala, program akan keluar dari blok Tiga dan Dua dan meneruskan pelaksanaan dalam blok Satu. Itu. dalam konsol kita akan melihat dua mesej: Tiga dan Satu.

Kesimpulan

Kami belajar tentang konsep gelung dalam Java, manakala utama dan untuk pernyataan, dan do-while dan untuk setiap bentuk, masing-masing. Untuk pemahaman yang lebih baik, kami mengesyorkan melakukan latihan menggunakan operator ini dalam pelbagai bentuk, serta pelbagai cara untuk mengganggu mereka dan bergerak dari satu blok ke blok yang lain.

Pernahkah anda terfikir mengapa program wujud sama sekali? Jika kita memudahkan dan menyamaratakan jawapan kepada soalan ini, ternyata program diperlukan untuk mengautomasikan proses kerja, meningkatkan kelajuan kerja yang dilakukan, melegakan seseorang daripada beribu-ribu tindakan membosankan, dan sebagainya. Mari fokus pada tindakan yang berulang satu demi satu, atau, secara ringkas, kitaran.

Kitaran ialah pelaksanaan berurutan bagi tindakan berulang berdasarkan prasyarat yang diberikan. Sebagai contoh, anda perlu memindahkan seratus kotak dari satu sudut ke sudut yang lain. Sekiranya kami menulis ini dalam Java (malangnya, Java tidak akan dapat menyusun semula kotak untuk anda), anda akan mendapat entri seratus baris:

1. ambil kotak No 1 dan letakkan di sudut lain;
2. ambil kotak No 2 dan letakkan di sudut lain;
3. ambil kotak No 3 dan letakkan di sudut lain;
…
100. ambil kotak No 100 dan letakkan di sudut lain;

Seratus baris kod sudah banyak, tetapi terdapat seribu, dua, tiga, dan seterusnya. Untuk tujuan ini, iaitu, untuk memudahkan rakaman tindakan berulang, kitaran digunakan.

Terdapat tiga operator yang mewakili gelung dalam bahasa Java - while, do/white dan for. Setiap pengendali adalah perlu dalam keadaannya sendiri, tetapi operator untuk masih paling kerap digunakan. Mari kita pertimbangkan setiap pengendali mengikut urutan.

manakala kenyataan

Sintaks untuk pernyataan while adalah seperti berikut:

While(condition) ( // actions )

Terdapat juga pemenuhan prasyarat tertentu, tetapi tidak seperti pernyataan if/else, pembinaan ini dibina berdasarkan kitaran menyemak keadaan. Apabila program mencapai pernyataan sementara, jika syarat yang dicadangkan adalah benar, semua tindakan dalam blok pendakap kerinting (...) dilaksanakan. Selepas melakukan tindakan ini, atur cara menyemak semula keadaan selepas penyataan sementara dan jika keadaan itu benar sekali lagi, tindakan dalam blok diulang. Tindakan dalam blok dilakukan sehingga keadaan menjadi palsu, dan hanya selepas itu gelung while keluar.
Untuk keluar dari gelung, apa yang dipanggil kaunter paling kerap digunakan. Mari kita lihat contoh kecil:

Int i = 0; Sementara saya< 10) { // действия i++; }

Pertama, pembolehubah i diberikan nilai 0, kemudian keadaan i0 diperiksa)

( // tindakan i--; )

Tindakan yang sama, tetapi dalam arah yang bertentangan. Selain itu, dalam gelung while (dan sememangnya gelung lain) adalah mungkin untuk menggunakan pembolehubah Boolean yang mengandungi nilai palsu atau benar. Dalam kes ini, prasyarat tertentu diperiksa.

Boolean i = benar; manakala (i) ( // tindakan )

Pembolehubah i adalah benar, ia diberikan nilai benar, jadi gelung while dilaksanakan sehingga pembolehubah i diberikan nilai palsu. Oleh itu, adalah perlu untuk menjaga keluar dari gelung tersebut, jika tidak gelung sementara akan dilaksanakan tanpa henti dan gelung tersebut dipanggil gelung tak terhingga.

Akhir sekali, saya ingin menarik perhatian anda kepada operator ==. Jika anda menulis kitaran dengan cara ini:

Int i = 0 manakala (i == 5) ( // tindakan i++; )

Ini akan menghasilkan gelung yang boleh dilaksanakan sepenuhnya, tetapi jika anda membuat kesilapan atau di luar kebiasaan menggunakan versi klasik operator equal = yang digunakan dalam matematik, maka anda akan menghadapi masalah dalam bentuk gelung tak terhingga.

Int i = 0 manakala (i = 5) ( // tindakan i++; )

Dalam prasyarat, pembolehubah i diberikan nilai 5, tetapi tindakan ini tidak dilarang, dan apa yang kita ada sebagai hasilnya? Pelaksanaan blok gelung ini akan bermula pada penghujungnya nilai i akan meningkat sebanyak satu, tetapi dalam prasyarat selepas penyataan sementara, pembolehubah i sekali lagi akan diberikan nilai lima dan gelung akan meneruskan iklan kerjanya infinitum. Ini adalah contoh gelung tak terhingga yang mudah dan, akibatnya, kesilapan klasik yang kerap berlaku kepada pengaturcara baru.

gelung do/while

Gelung sementara yang baru kita lihat mungkin tidak berfungsi dalam keadaan tertentu. Sebagai contoh, jika syarat pada mulanya palsu, gelung tidak akan dilaksanakan walaupun sekali. Program ini, apabila ia mencapai baris kod dengan pernyataan sementara, akan menyemak keadaan dan jika ia palsu, ia akan mengabaikan keseluruhan gelung dan beralih kepada kod serta-merta mengikuti gelung while. Tetapi kadangkala terdapat keperluan untuk melaksanakan gelung sekurang-kurangnya sekali. Java mempunyai gelung do/while untuk tujuan ini. Merakam dan mencipta gelung do/while dilakukan seperti berikut:

Lakukan ( // tindakan ) sambil (syarat)

Di antara pernyataan do dan while terdapat badan gelung yang akan dilaksanakan sehingga postcondition berikutan pernyataan while adalah palsu. Badan gelung akan dilaksanakan sekurang-kurangnya sekali, selepas itu keadaan akan diperiksa. Gelung do/while tidak kerap digunakan, tetapi kadangkala ia ternyata sangat diperlukan.

untuk gelung

Ini adalah gelung yang paling biasa dalam pengaturcaraan. Gelung for berfungsi dengan mengawal pembilang. Maksud gelung ini adalah serupa dengan gelung while dan do/while yang dibincangkan di atas. Lihatlah rupa sintaks untuk gelung for:

Untuk (int i = 0; i< 10; i++) { // действие }

Selepas kata kunci untuk, datang syarat untuk melaksanakan gelung. Keadaan itu sendiri menggabungkan tiga peringkat. Mula-mula, pembilang i = 0 dimulakan, kemudian keadaan i diperiksa< 10 и в конце увеличение переменной i на единицу.

Gelung for berfungsi seperti berikut. Apabila atur cara mencapai gelung, pembilang i = 0 dimulakan dan keadaan i diperiksa< 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.

Kemas kini terakhir: 31/10/2018

Satu lagi jenis struktur kawalan ialah gelung. Gelung membolehkan anda melakukan tindakan tertentu beberapa kali bergantung pada syarat tertentu. Java mempunyai jenis gelung berikut:

untuk gelung

Gelung for mempunyai definisi formal berikut:

Untuk ([mulakan pembilang]; [keadaan]; [tukar pembilang]) ( // tindakan )

Pertimbangkan standard untuk gelung:

Untuk (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }

Bahagian pertama pengisytiharan gelung - int i = 1 mencipta dan memulakan pembilang i. Kaunter tidak semestinya jenis int . Ia boleh menjadi jenis berangka lain, contohnya terapung. Sebelum gelung dilaksanakan, nilai pembilang ialah 1. Dalam kes ini, ini adalah sama seperti mengisytiharkan pembolehubah.

Bahagian kedua ialah keadaan di mana gelung akan dilaksanakan. Dalam kes ini, gelung akan berjalan sehingga saya mencapai 9.

Dan bahagian ketiga menambah satu kaunter. Sekali lagi, kita tidak semestinya perlu menambah satu. Anda boleh mengurangkan: i-- .

Akibatnya, blok gelung akan berjalan 8 kali sehingga nilai i menjadi sama dengan 9. Dan setiap kali nilai ini akan meningkat sebanyak 1.

Kami tidak perlu menentukan semua syarat apabila mengisytiharkan gelung. Sebagai contoh, kita boleh menulis seperti ini:

Int i = 1; untuk (; ;)( System.out.printf("Kuasa dua bagi %d ialah %d \n", i, i * i); )

Takrif gelung kekal sama, cuma kini blok dalam takrifan kosong: untuk (; ;) . Kini tiada pembolehubah pembilang yang dimulakan, tiada syarat, jadi gelung akan berjalan selama-lamanya - gelung tak terhingga.

Atau anda boleh meninggalkan beberapa blok:

Int i = 1; untuk (; i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }

Contoh ini bersamaan dengan contoh pertama: kami juga mempunyai pembilang, tetapi ia dibuat di luar gelung. Kami mempunyai keadaan pelaksanaan gelung. Dan terdapat kenaikan kaunter yang sudah ada di blok untuk itu sendiri.

A for loop boleh mentakrifkan dan memanipulasi berbilang pembolehubah sekaligus:

Int n = 10; untuk(int i=0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }

buat gelung

Gelung do mula-mula melaksanakan kod gelung dan kemudian menguji keadaan dalam pernyataan while. Dan selagi keadaan ini benar, kitaran berulang. Sebagai contoh:

Int j = 7; lakukan( System.out.println(j); j--; ) manakala (j > 0);

Dalam kes ini, kod gelung akan dijalankan 7 kali sehingga j sama dengan sifar. Adalah penting untuk ambil perhatian bahawa gelung do menjamin bahawa tindakan itu akan dilaksanakan sekurang-kurangnya sekali, walaupun keadaan dalam pernyataan while tidak benar. Jadi, kita boleh menulis:

Int j = -1; lakukan( System.out.println(j); j--; ) manakala (j > 0);

Walaupun j pada mulanya kurang daripada 0, gelung masih akan dilaksanakan sekali.

gelung semasa

Gelung while segera menyemak kebenaran beberapa syarat, dan jika syarat itu benar, maka kod gelung dilaksanakan:

Int j = 6; manakala (j > 0)( System.out.println(j); j--; )

Teruskan dan putuskan kenyataan

Pernyataan putus membolehkan anda keluar dari gelung pada bila-bila masa, walaupun gelung belum menyelesaikan kerjanya:

Sebagai contoh:

< nums.length; i++){ if (nums[i] >10) rehat; System.out.println(bilangan[i]); )

Memandangkan gelung menyemak sama ada elemen tatasusunan lebih besar daripada 10, kita tidak akan melihat dua elemen terakhir pada konsol, kerana apabila nums[i] lebih besar daripada 10 (iaitu, sama dengan 12), penyataan pecah akan berfungsi dan gelung akan berakhir.

Benar, kita juga tidak akan melihat elemen terakhir, iaitu kurang daripada 10. Sekarang kita akan memastikan bahawa jika nombor lebih besar daripada 10, gelung tidak akan berakhir, tetapi hanya beralih ke elemen seterusnya. Untuk melakukan ini, kami menggunakan operator teruskan:

Int nums = new int ( 1, 2, 3, 4, 12, 9 ); untuk (int i = 0; i< nums.length; i++){ if (nums[i] >10) teruskan; System.out.println(bilangan[i]); )

Dalam kes ini, apabila gelung mencapai nombor 12, yang tidak memenuhi syarat ujian, program hanya akan melangkau nombor ini dan beralih ke elemen tatasusunan seterusnya.

Apabila anda memerlukan tindakan yang sama untuk dilakukan beberapa kali atau sehingga syarat tertentu dipenuhi, gelung datang untuk membantu kami.

Terdapat beberapa cara untuk membuat gelung dalam Java. Seperti yang anda duga, kami akan mempertimbangkan semuanya.

Cara pertama untuk mengisytiharkan gelung adalah menggunakan binaan berikut: untuk (keadaan permulaan gelung; keadaan akhir; langkah di mana gelung akan pergi) (badan gelung)

Mari beralih terus ke contoh. Katakan kita mempunyai tugas untuk memaparkan frasa "hello world" sebanyak 10 kali. Jika anda tidak menggunakan gelung, anda hanya boleh menulis System.out.println("Hello world"); sepuluh kali dan kami akan menyelesaikan masalah itu. Mari gunakan gelung untuk tujuan ini. Buat kelas baharu dan panggil sebagai contoh CuclesInJava. Sekarang isytiharkan keadaan gelung (biar 0), keadaan akhir - 10, dan langkah. Kami akan pergi dalam kenaikan satu. Dalam badan gelung, letakkan baris System.out.println("Hello world");

Berikut ialah contoh kod:

Hasil daripada kod ini ialah 10 baris dalam baris frasa "Hello world!"

Bagaimana pula dengan menulis sesuatu yang lebih kompleks. Kami telah mempelajari yang asas. Mari kita gunakan mereka.

Mari tulis aplikasi mudah yang akan memaparkan garis amaran setiap kali langkah + beberapa pembolehubah adalah sama dengan 5. Saya sangat buruk pada imaginasi))

Mula-mula, mari tulis kod yang akan menerima sebagai input pembolehubah yang dimasukkan daripada konsol. Dalam artikel sebelumnya, saya memberikan contoh kod ini dan kami bersetuju bahawa kemudian saya akan menerangkan cara ia berfungsi dan dari mana ia datang. Dan sekarang kita hanya akan menggunakannya:

Seterusnya, anda perlu menulis gelung yang akan bermula dari sifar dan mengira hingga sepuluh (seperti dalam contoh sebelumnya). Dalam badan gelung kami akan menulis pernyataan bersyarat yang akan menyemak sama ada pembolehubah ini sama dengan 5 dan jika ya, maka kami akan mengeluarkan baris "OK". Inilah yang saya dapat:

import java.util.Scanner ;

CuclesInJava kelas awam(

int pembolehubah = scanner.nextInt(); //kita akan melakukannya secara beransur-ansur dan kemudian ia akan menjadi jelas cara ia berfungsi

untuk (int i = 1 ; i< 10 ; i++ ) {

int newVariable = i + variable;

jika (NewVariable==5) (

Ia tidak menjadi sangat rumit. Dengan contoh ini, saya ingin menunjukkan bagaimana anda boleh menggunakan gelung dengan cawangan bersama-sama.

Cara seterusnya untuk mengisytiharkan gelung adalah dengan konstruk: while(condition is true)(blok kod yang akan dilaksanakan). Reka bentuk ini mempunyai bentuk lain:

lakukan(blok kod yang akan dilaksanakan)sementara(keadaan adalah benar). Perbezaan antara yang pertama dan yang kedua ialah yang kedua melaksanakan satu gelung tanpa mengira sama ada keadaan itu benar atau tidak. Anda boleh berfikir sendiri: mula-mula kami melaksanakan kod, dan kemudian kami menyemak keadaan. Dan walaupun syarat itu tidak benar, kod itu masih akan dilaksanakan sekali, pada masa apabila dalam jenis pembinaan pertama syarat itu pertama kali diperiksa dan sehingga ia benar, kod itu tidak akan dilaksanakan.

Kod harus intuitif. Saya fikir ia patut disebut bahawa dengan binaan sambil dan lakukan sambil anda boleh "gelung" atur cara jika syarat untuk keluar dari gelung tidak dinyatakan atau dinyatakan secara salah. Lihat contoh di atas dan fikirkan apa yang akan berlaku jika saya menulis bukan i—, tetapi i++; atau bukannya i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

Nah, contoh dengan do-while:

Mengenai ini, saya fikir, kita boleh menyelesaikan artikel tentang gelung di Jawa. Seperti yang anda lihat, reka bentuknya tidak begitu rumit, tetapi sangat berguna. Ia akan berguna terutamanya apabila kita membiasakan diri dengan tatasusunan dan rentetan.