Döngü türleri java. Java'da döngüler. Arayı bir goto olarak kullanma

Son güncelleme: 31.10.2018

Döngüler başka bir kontrol yapısı türüdür. Döngüler, belirli koşullara bağlı olarak, belirli bir eylemi birden çok kez gerçekleştirmeye izin verir. Java dili aşağıdaki döngü türlerine sahiptir:

Döngü için

Bir for döngüsü aşağıdaki biçimsel tanıma sahiptir:

([sayaç başlatma]; [koşul]; [sayaç değişikliği]) için (// eylemler)

Döngü için bir standart düşünün:

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

Döngü bildiriminin ilk kısmı - int i = 1, sayaç i'yi oluşturur ve başlatır. Sayacın int türünde olması gerekmez. Başka herhangi bir sayısal tür olabilir, örneğin kayan nokta. Döngü yürütülmeden önce sayaç 1 olacaktır. Bu durumda, bu bir değişken bildirmekle aynıdır.

İkinci kısım, döngünün yürütüleceği koşuldur. Bu durumda döngü i 9'a ulaşana kadar çalışacaktır.

Üçüncü kısım ise sayacı birer birer artırmaktır. Yine, birer birer artırmamıza gerek yok. Azaltılabilir: i--.

Sonuç olarak, döngü bloğu i değeri 9'a eşit olana kadar 8 kez çalışacaktır ve bu değer her seferinde 1 artacaktır.

Bir döngü bildirirken tüm koşulları belirtmemize gerek yoktur. Örneğin şöyle yazabiliriz:

Int i = 1; for (;;) (System.out.printf ("% d'nin karesi %d \ n'dir", i, i * i);)

Döngünün tanımı aynı kalır, ancak şimdi tanımdaki bloklar boştur: for (;;). Şimdi başlatılmış sayaç değişkeni yok, koşul yok, bu nedenle döngü sonsuza kadar çalışacak - sonsuz bir döngü.

Alternatif olarak, bir dizi bloğu atlayabilirsiniz:

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

Bu örnek ilk örneğe eşdeğerdir: ayrıca bir sayacımız var, sadece döngü dışında yaratılmıştır. Döngünün yürütülmesi için bir koşulumuz var. Ve for bloğunun kendisinde zaten bir sayaç artışı var.

for döngüsü aynı anda birkaç değişkeni tanımlayabilir ve değiştirebilir:

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

döngü yap

Do döngüsü önce döngü kodunu çalıştırır ve ardından while ifadesindeki koşulu kontrol eder. Ve bu koşul doğru olduğu sürece döngü tekrar eder. Örneğin:

Int j = 7; do (System.out.println (j); j--;) while (j> 0);

Bu durumda, döngü kodu j sıfıra eşit olana kadar 7 kez çalışacaktır. while ifadesindeki koşul doğru olmasa bile, do döngüsünün eylemin en az bir kez yürütülmesini garanti ettiğini belirtmek önemlidir. Yani şunu yazabiliriz:

Int j = -1; do (System.out.println (j); j--;) while (j> 0);

j başlangıçta 0'dan küçük olmasına rağmen, döngü yine de bir kez yürütülecektir.

Döngü sırasında

while döngüsü, bazı koşulların doğruluğunu hemen kontrol eder ve koşul doğruysa, döngü kodu yürütülür:

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

Devam ve mola ifadeleri

break ifadesi, döngü işini bitirmemiş olsa bile, herhangi bir anda döngüden çıkmanıza izin verir:

Örneğin:

< nums.length; i++){ if (nums[i] >10) ara; System.out.println (sayılar [i]); )

Döngü, dizi öğesinin 10'dan büyük olup olmadığını kontrol ettiğinden, konsolda son iki öğeyi görmeyeceğiz, çünkü nums [i] 10'dan büyük olduğunda (yani, 12'ye eşit), break ifadesi tetiklenir. ve döngü sona erecek.

Doğru, 10'dan küçük olan son elemanı da görmeyeceğiz. Şimdi, sayı 10'dan büyükse döngü bitmeyecek, sadece bir sonraki elemana geçecek şekilde yapacağız. Bunu yapmak için devam operatörünü kullanın:

Int sayıları = yeni int (1, 2, 3, 4, 12, 9); for (int i = 0; ben< nums.length; i++){ if (nums[i] >10) devam et; System.out.println (sayılar [i]); )

Bu durumda, döngünün yürütülmesi, test koşulunu karşılamayan 12 sayısına ulaştığında, program bu sayıyı atlayacak ve dizinin bir sonraki öğesine geçecektir.

Programların neden var olduğunu hiç merak ettiniz mi? Bu sorunun cevabını basitleştirir ve genelleştirirsek, iş akışını otomatikleştirmek, yapılan işin hızını artırmak, bir insanı binlerce monoton eylemden kurtarmak vb. için programların gerekli olduğu ortaya çıkar. Eylemleri birbiri ardına tekrarlamaya veya basit bir ifadeyle döngülere odaklanalım.

Döngü, belirli bir ön koşula dayalı olarak tekrarlayan eylemlerin sıralı yürütülmesidir. Örneğin, yüz kutuyu bir köşeden diğerine yeniden düzenlemeniz gerekiyor. Bir şekilde Java dilinde yazarsanız (maalesef Java kutuları sizin için yeniden düzenleyemez), o zaman yüz satır alırsınız:

1. 1 numaralı kutuyu alın ve başka bir köşeye koyun;
2. 2 numaralı kutuyu alın ve başka bir köşeye koyun;
3. 3 numaralı kutuyu alın ve başka bir köşeye koyun;
…
100. 100 numaralı kutuyu alın ve başka bir köşeye koyun;

Yüz satır kod zaten çok fazla, ancak bin, iki, üç vb. var. Bu amaçlar için, yani tekrarlayan eylemlerin kaydını basitleştirmek için döngüler kullanılır.

Java dilinde döngüleri temsil eden üç ifade vardır - while, do / white ve for. Operatörlerin her biri kendi durumunda gereklidir, ancak for operatörü hala en sık kullanılmaktadır. Operatörlerin her birini sırayla ele alalım.

ifade ederken

while ifadesinin sözdizimi aşağıdaki gibidir:

while (koşul) (// eylemler)

Belirli bir ön koşulun yerine getirilmesi de gerçekleşir, ancak if / else operatörünün aksine, bu yapı koşul kontrol döngüleri üzerine kuruludur. Program while deyimine ulaştığında, önerilen koşul doğruysa, küme parantezleri (...) bloğundaki tüm eylemler yürütülür. Bu işlemler tamamlandıktan sonra, while ifadesinden sonra program tekrar koşulun tekrar kontrolünü yapar ve koşul tekrar doğru ise bloktaki işlemler tekrarlanır. Bloktaki eylemler, koşul yanlış olana kadar yürütülür ve ancak o zaman while döngüsü çıkar.
Döngülerden çıkmak için en sık olarak sözde sayaçlar kullanılır. Küçük bir örnek düşünün:

Int ben = 0; süre (ben< 10) { // действия i++; }

İlk olarak, i değişkenine 0 değeri atanır, ardından i0 koşulu kontrol edilir)

(// eylemler i--;)

Aynı eylemler, ancak ters yönde. Ek olarak, while döngüsünde (ve aslında diğer döngülerde), yanlış veya doğru değerler içeren boole değişkenlerini kullanmak mümkündür. Bu durumda, belirli bir ön koşul kontrol edilir.

Boolean i = doğru; while (i) (// eylemler)

i değişkenine true değeri atanır, bu nedenle while döngüsü, i değişkenine false değeri atanana kadar yürütülür. Bu nedenle, böyle bir döngüden çıkmaya özen göstermeniz gerekir, aksi takdirde while döngüsü süresiz olarak çalışır ve bu tür döngülere sonsuz döngüler denir.

Son olarak, == eşittir operatörüne dikkatinizi çekmek istiyorum. Döngüyü şöyle yazarsanız:

Int i = 0 while (i == 5) (// eylemler i ++;)

Bu tamamen uygulanabilir bir döngü olacak, ancak bir hata yaparsanız veya alışkanlıktan dolayı, operatörün matematikte kullanılan = eşittir klasik versiyonunu kullanırsanız, sonsuz döngü şeklinde bir probleminiz olacaktır.

Int i = 0 while (i = 5) (// eylemler i ++;)

Ön koşulda, i değişkenine 5 değeri atanır, ancak bu eylem yasak değildir ve sonuçta ne elde ederiz? Döngünün bu bloğunun yürütülmesi sonunda i'nin değeri bir artacak, ancak while ifadesinden sonraki ön koşulda, i değişkenine tekrar beş değeri atanacak ve döngü çalışmasına devam edecektir. süresiz olarak. Bu, basit bir sonsuz döngünün bir örneğidir ve sonuç olarak, acemi programcılarda çok sık meydana gelen klasik bir hatadır.

Do / while döngüsü

Bizim tarafımızdan incelenen while döngüsü, belirli koşullar altında çalışmayabilir. Örneğin, koşul başlangıçta yanlışsa, döngü asla yürütülmez. Program while deyimi ile kod satırına ulaştığında durumu kontrol edecek ve eğer yanlış ise tüm döngüyü yok sayarak while döngüsünün hemen ardından koda gidecektir. Ancak bazen döngüyü en az bir kez çalıştırmak gerekli hale gelir. Bu amaçlar için Java'nın bir do / while döngüsü vardır. do / while döngüsü şu şekilde yazılır ve oluşturulur:

Yap (// eylemler) while (koşul)

do ve while ifadeleri arasında, while ifadesini izleyen son koşul false olana kadar yürütülecek bir döngü gövdesi vardır. Döngünün gövdesi en az bir kez yürütülecek ve ardından koşul kontrol edilecektir. Do / while döngüsü çok sık kullanılmasa da bazen vazgeçilmez olduğu ortaya çıkıyor.

Döngü için

Bu, programlamadaki en yaygın döngüdür. For döngüsü, sayaç manipülasyonuna dayanır. Bu döngünün anlamı, yukarıda tartışılan while ve do / while döngülerine benzer. Bir for döngüsünün sözdiziminin nasıl göründüğüne bakın:

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

for anahtar sözcüğünü, döngüyü yürütmek için bir koşul izler. Durumun kendisi üç aşamayı birleştirir. Önce i = 0 sayacının başlatılması, ardından i koşulunun kontrol edilmesi gelir.< 10 и в конце увеличение переменной i на единицу.

For döngüsü aşağıdaki gibi çalışır. Program döngüye ulaştığında, i = 0 sayacı başlatılır ve i koşulu kontrol edilir.< 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.

Java'da, hemen hemen tüm programlama dillerinde olduğu gibi, belirli bir kod parçasının veya kendi adıyla döngülerin çoklu tekrarını sağlamak için araçlar vardır. Java'daki döngüler, for ve while gibi ifadeler ve bunların türevleriyle temsil edilir. Kural olarak, döngüler, belirli öğeleri ve bunlarla başka işlemleri bulmak için tek boyutlu ve çok boyutlu diziler ve yinelenebilir veri yapıları (koleksiyonlar dahil) üzerinde yineleme yapmak için kullanılır. Ancak, Java Döngüsü gibi bir aracı kullanmanın tek yolu bu değildir. Kullanım durumları değerlendirildikçe sağlanacaktır.

Java: açıklama ve örnekler

Java'daki temel döngü operatörü while'dır. Gövdesi içine alınan kod parçası, parantez içindeki ifadenin koşulu, gerçeğin mantıksal değerini karşıladıktan sonra tekrarlanacaktır. while ifadesinin genel biçimi aşağıdaki gibidir:

while (koşul) (

// döngünün gövdesi

Mantıksal koşulun değeri doğru olmaktan çıkar çıkmaz, döngünün gövdesinde yer alan kodun çalışması duracak ve kontrol, hemen ardından gelen satıra aktarılacaktır.

Döngünün gövdesinde yalnızca bir operatör varsa, küme parantezleri atlanabilir, ancak her zaman görünüyorlarsa iyi form olarak kabul edilir. Yukarıdaki şekil, bu operatörün çalışmasının bir blok şemasını göstermektedir.

Netlik için, aşağıdaki şekilde gösterilen örneğe bir göz atalım:

Bildirilen değişken sayısı başlangıçta 1 değerine sahiptir. Ardından, operatör adından sonra parantez içine alınmış bir boole ifadesi görürüz. Doğru olacak, yani. count değişkeninin değeri 10'dan küçük veya ona eşit olduğu sürece true döndürür. Döngünün gövdesinde, her geçişte (yineleme) değişkenin değeri 1 artırılır ve konsol ekranında görüntülenir. Değişken 11'e ulaştığında döngünün çalışmayı durdurduğunu unutmayın.

Değişkenin değeri başlangıçta 11'e eşit olsaydı, döngü koşulu yanlış olurdu ve program gövdesine bile girmezdi.

Java sözdiziminin bir while ifadesini gövde olmadan kullanmanıza izin verdiğini belirtmekte fayda var. Bir örnek verelim. Diyelim ki iki değişkenimiz var i = 100 ve j = 200, aritmetik ortalamalarını programlı olarak hesaplama göreviyle karşı karşıyayız - bunun için "içi boş" kullanabilirsiniz:

süre (++ ben< --j);

Sonuç olarak, iki değişkenden birinin değeri, orijinal değerlerinin ortalamasına eşit olacaktır. Gördüğünüz gibi, döngü bir gövde olmadan iyi çalıştı ve gerekli tüm eylemleri koşullu bir ifadede gerçekleştirdi.

Do-while döngüsü

Önceki örneklerde, koşullu ifade başlangıçta false döndürürse, program yürütme döngünün gövdesini yok sayar ve devam ederdi. Bununla birlikte, koşullu ifadenin doğruluğundan bağımsız olarak, döngü gövdesinde yer alan kodun yürütülmesinin en az bir kez zorunlu olduğu durumlar sıklıkla ortaya çıkar. Başka bir deyişle, koşullu bir ifadenin doğruluğunu döngünün başında değil, sonunda kontrol etmek gerekir. while döngüsünün do-while adı verilen bir varyasyonu bu işlevi sağlayabilir. Aşağıdaki forma sahiptir:

yapmak (
// döngünün gövdesi

) while (koşul);

Gördüğümüz gibi, önce döngünün gövdesi yürütmeye gider ve ancak o zaman koşulun doğruluğu kontrol edilir - ve bu her yinelemede böyle devam eder.

Yukarıdaki kod, normal bir süre ile aynı şekilde çalışacaktır. Bununla birlikte, sayım değişkenine 11 değerini atasaydık, operatör ifadenin doğru olduğunu test etmeden önce döngünün gövdesi yine de bir kez yürütülürdü.

- Java döngüsü için açıklama ve örnekler

Java'da çok yönlü ve verimli bir dil biçimidir. Java SDK'nın beşinci sürümünden önce, for ifadesinin yalnızca bir geleneksel biçimi vardı ve ardından her biri için yeni bir tane ortaya çıktı. Bu bölümde, operatörün geleneksel formu ile tanışacağız. Java için döngü şöyle görünür:

Kontrol, döngünün gövdesindeki koda aktarılmadan önce, i değişkeni bir sayaç görevi görmesi için başlatılır. Ardından, sayacın belirli bir değerle karşılaştırıldığı koşullu bir ifade kontrol edilir ve eğer doğru dönerse, döngünün gövdesi yürütülür. Daha sonra sayaç değeri önceden belirlenmiş bir adımla değiştirilir ve koşullu ifade tekrar kontrol edilir ve bu, koşul yanlış olana kadar devam eder. Aşağıdaki akış şeması, döngünün tüm aşamalarını göstermektedir.

Daha iyi bir anlayış için, burada for Java döngüsünün nasıl çalıştığına dair bir örnek:

LoopVal değişkeninin sayaç olarak kullanıldığını görebiliriz. Döngünün her yinelemesinden sonra değeri 1 artacaktır ve bu 11'e ulaşana kadar devam edecektir. Kontrol değişkeninin for ifadesinin dışında bildirilebileceğini unutmayın, ancak bu değişkeni bir değişken dışında herhangi bir yerde kullanmayacaksanız. döngü, doğrudan ifadede bildirmeniz önerilir. İfadenin kendisinde bildirilen bir değişkenin, o döngünün kendisinde kapsam dahilinde olduğunu unutmayın.

Döngüyü kontrol eden birkaç değişken bildirmeniz gereken durumlar vardır. Java için bir döngü, virgülle ayrılmış iki veya daha fazla değişken belirtmenize izin verir ve bu, hem başlatma sırasında hem de yineleme sırasında yapılabilir. Böyle bir operatör şöyle görünecektir:

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

Her yinelemede, i değişkeninin değeri 1 artacak ve j değişkeninin değeri 1 azalacak.

for operatörünü kullanmanın özellikleri

For döngüsü oldukça esnektir, çünkü üç parçasının tümü (başlatma, koşul ve artırma / eksiltme) etiket dışı kullanılabilir. Örneğin, bir kontrol değişkenli koşullu ifade yerine, herhangi bir boole değişkenini değiştirebilirsiniz.

boolean çıkış = yanlış;

for (int i = 0;! çıkış; ++ i) (

Yukarıdaki örnekte, döngünün çalışmasının i kontrol değişkeninden nasıl tamamen bağımsız olduğunu ve yineleme sayısının yalnızca değişken çıkışının doğru olduğu ana bağlı olduğunu gözlemleyebiliriz. Ayrıca, kontrol değişkeni döngüden tamamen çıkarılabilir ve bu, çalışmasını hiçbir şekilde etkilemeyecektir: for (;! Exit;) (). Programlamanın en akıllı yolu olmasa da bazen faydalı olabilir. Ana şey, değişkenin sonsuz hale getirmemek için döngüden çıkmak için gerekli değeri alacağı bir durumu öngörmektir.

Java için bir döngü şu şekilde bildirilebilir: for (;;) (). Bu, özel kesme koşullarına sahip bir sonsuz döngünün tipik bir örneğidir. Bu tür döngülerin nasıl kesileceğinden biraz sonra bahsedeceğiz.

Her döngü için

Java foreach döngüsü her zaman bir dizinin veya başka bir şeyin öğelerini yinelemek ve bunlar üzerinde belirli tekrarlayan işlemleri gerçekleştirmek için kullanılır. Bu for deyiminin bir örneği aşağıda gösterilmiştir:

Ad, bir yineleme değişkeni olarak bildirildi ve daha önce bildirilen dizelerin adlar dizisi, operatörün ikinci argümanıdır. Değişken adı, tüm öğeleri alınana kadar sırayla dizinin her bir öğesinin değerlerini alacaktır. Değişkenin tipinin dizide saklanan elemanların tipi ile uyumlu olması gerektiğine dikkat edilmelidir. Ayrıca, ad değişkeni yalnızca okuma için kullanılabilir ve onu değiştirme girişimi, dizideki öğenin kendisini değiştirmez.

Kesinti Döngü Operatörleri

Üç döngü sonu ifadesi vardır: break, return ve Continue. İlk ikisi, döngünün çalışmasını tamamen kesintiye uğratabilir, devam ise yalnızca geçerli yinelemenin çalışmasını kesintiye uğratır. Kodunuzda kasıtlı olarak sonsuz bir Java döngüsü kullanıyorsanız, bu operatörler kodda bulunmalıdır. Break kullanımına ilişkin basit bir örneğe bakalım:

Bu for ifadesi 11 yineleme sağlasa da, yalnızca 8 tanesi yürütülecektir, çünkü i sayacı 7 olduğunda, gövdesinde bir break ifadesinin bulunduğu koşul tetiklenecektir.

Return ifadesi, yalnızca Java döngüsünden değil, aynı zamanda döngünün yerleştirildiği yöntemden de çıkması farkıyla benzer şekilde çalışır.

Arayı bir goto olarak kullanma

Break'in yalnızca doğrudan bulunduğu gövdedeki döngünün çalışmasını kesintiye uğrattığı akılda tutulmalıdır, yani. bunu iç içe bir döngüde kullanırsanız, dış döngü çalışmayı durdurmaz. Bunun için break ifadesi medeni bir goto biçimi olarak kullanılabilir.

Bu sürümde, bu operatör, yalnızca döngülerden değil, aynı zamanda herhangi bir kod bloğundan bir çıkış düzenlemenize izin veren bir etiketle birlikte kullanılır. Etiket, uygun şekilde adlandırılmış bir tanımlayıcı ve ardından iki nokta üst üste işaretidir. Etiket, işaretlenecek kod bloğunun başında bildirilir. İşaretli bir bloğun yürütülmesini kesintiye uğratmak için doğru yerde bildirmelisiniz: break tag_name. Aşağıdaki şekildeki örneği göz önünde bulundurun:

Kod, sırasıyla Bir, İki ve Üç etiket adlarına sahip üç blok bildirir. Two etiketli break ifadesi üç bloğun hepsinde yuvalanmıştır, ancak tetiklendiğinde program Üç ve İki bloktan çıkar ve Bir blokta yürütmeye devam eder. Onlar. konsolda iki mesaj göreceğiz: Üç ve Bir.

Çözüm

Java'daki döngü kavramı, ana while ve for deyimleri ve bunların do-while ve her form için sırasıyla tanıdık. Daha iyi bir anlayış için, bu operatörleri çeşitli şekillerde kullanmanın yanı sıra onları kesmenin ve bir bloktan diğerine geçmenin çeşitli yollarını kullanmanızı öneririz.

08/12/17 1.9K

Java While Do döngüsü, aynı kod parçasını birden çok kez çalıştırmanıza izin veren bir ifadedir. Bu döngü, koşullar karşılandığında eylemleri tekrarlamak için kullanılabilir.

Döngü sırasında

while döngüsü Java'da oluşturulması en kolay olanıdır. Bir while anahtarı, bir döngü koşulu ve bir döngü gövdesinden oluşur:

while (koşul) (// döngü gövdesi)

Döngü gövdesinin her bir bireysel çalışması bir yineleme olarak kabul edilir. Döngü koşulları, her yinelemeden önce değerlendirilir. Gövdesi, yalnızca değerlendirme sonuçlarındaki döngü koşulları doğruysa yürütülür.

Döngünün yinelemeleri bir şeyi değiştirir ve belirli bir noktada koşulların değerlendirilmesi false döndürür ve ardından döngü biter. Koşul hiçbir zaman false döndürmeyen bir döngü sonsuz sayıda yürütülür. Bu tür döngülere sonsuz denir.

Örnek

int sayı = 0; while (sayı< 10) { System.out.println(num); num++; }

Bu örnek, 0'dan 9'a kadar olan sayıları yazdırır. Kodu adım adım inceleyelim. İlk olarak, num değişkenini 0 değeriyle başlatıyoruz. Bu döngü sayacı olacaktır. Program while'a ulaştığında döngünün koşullarının karşılanıp karşılanmadığını değerlendirir. bizim durumumuzda 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

İlk "çalıştırmadan" sonra, Java while Loop koşulu ikinci kez değerlendirilir. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

Son yineleme, num 9 olduğunda başlar. Döngü sayacı son kez görüntülenir ve değer 10'a yükseltilir. Bu sefer, döngü koşulu yanlış olarak değerlendirdiği için yeni bir yineleme başlatılamaz. 10, 10'dan az olmadığı için.

Böylece, döngünün koşulu yürütüldüğü sürece döngü başlatılır. Bu bilgiyle donanmış olarak, daha karmaşık ve işlevsel döngüler oluşturabilirsiniz. Diziyi yineleyelim:

Dize isimleri = ("Doc", "Aptal", "Utangaç", "Huysuz", "Sinsi", "Uykulu", "Mutlu"); int dizin = 0; while (dizin< names.length) { System.out.println(names); index++; }

Bu örneğin konsepti bir öncekine benzer. Döngü sayacını başlatırız ve tüm öğeler görüntülenene kadar dizi üzerinde yinelemeye başlarız. Sonuç olarak, diziler üzerinde yineleme yapmak oldukça yaygın bir durumdur ve Java bunun için daha uygun bir yapıya sahiptir - For döngüsü.

Do-while döngüsü

Java while do döngüsü while'a benzer, ancak önemli bir farkı vardır: while'ın aksine, burada koşul her yinelemenin sonunda kontrol edilir. Bu, do-while döngüsünün her zaman en az bir kez yürütüldüğü anlamına gelir:

do (// döngü gövdesi) while (koşul);

Örnek

do-while, önce döngünün gövdesini yürütür ve ardından koşullarını değerlendirir. Sonuca bağlı olarak, döngü durur veya bir sonraki yineleme başlar. İsim oyununa basit bir tahminde bulunalım:

Tarayıcı tarayıcı = yeni Tarayıcı (System.in); Dize tahmini; do (System.out.print ("Adını tahmin et:"); tahmin = tarayıcı.nextLine ();) while (! "Daffy Duck" .eşittir (tahmin)); System.out.println ("Tebrikler! Adımı tahmin ettiniz!");

Bu, Java örneği, system.ini'den girişi ayrıştırmak için Tarayıcı'yı kullanırken. Bu, çoğu durumda klavyeyle etkileşime giren standart giriş borusudur. Basitçe söylemek gerekirse, oyuncunun girdiği metni okuyoruz.

Oyunda, kullanıcıya en az bir kez sormalısınız ve oyuncu doğru cevapları girdiği sürece bunu yapmalısınız. Do-while döngüsü bu tür durumlar için idealdir. Döngünün gövdesinde özel değeri alırız ve ardından doğru cevap kontrol edilir. Döngü, kullanıcının girdiği değer Daffy Duck'a eşit olana kadar çalışmalıdır. Doğru cevap alınırsa döngü durur ve oyuncuyu zaferinden dolayı tebrik ederiz.

Sonuç olarak

Java while true döngüleri, kod parçacıklarını birden çok kez yeniden kullanmanıza olanak tanır. Bugün Java while ve do-while döngülerini gördük. Koşulları kontrol etmeleri ve koşul doğru olarak değerlendirilirse döngü gövdesini yürütmeleri bakımından benzerdirler. Ancak aynı zamanda önemli bir farkları vardır: while döngüsünün durumu yinelemeden önce kontrol edilir ve do-while döngüsünün durumu her yinelemenin sonunda kontrol edilir. Bu, do-while döngüsünün her zaman en az bir kez yürütüldüğü anlamına gelir.

Bu yayın, makalenin bir çevirisidir " Java'nın Beş Dakikada Süre ve Do-While Döngüleri"Güleryüzlü proje ekibi tarafından hazırlanmıştır.

Aynı türden çok sayıda veriyi işlemeniz mi gerekiyor? Bir dizi hesaplamanız mı gerekiyor? Matrisleri çarpmanız mı gerekiyor? Bütün bunlar ve çok daha fazlası, döngüyü oluşturmaya yardımcı olacak! 🙂 Tüm bilgi işlem sistemleri, başlangıçta veri işlemeyi kolaylaştırmak için tasarlandı. Ve büyük miktarda verinin işlenmesi, döngüler olmadan hayal bile edilemez.

Genel olarak, programlama döngüleri genellikle üç gruba ayrılır. İlk grup karşı döngülerdir. Onlarda, döngünün gövdesi, başlangıçta programcı tarafından ayarlanan birkaç kez yürütülür. Böyle bir döngü mutlaka belirli bir sayıda yürütülecektir. İkinci grup, ön koşullu döngülerdir. Onlarda, döngünün gövdesi yalnızca bazı koşullar kontrol edildikten sonra yürütülür ve bu koşul doğru olduğu sürece yürütülür. Bu tür döngüler bir kez bile çalıştırılamaz (eğer koşul başlangıçta yanlışsa). Ve üçüncü döngü grubu, bir son koşullu döngülerdir. Önce döngünün gövdesini yürütürler, ardından koşulu kontrol ederler. Bu döngü en az bir kez çalışacaktır.

Sayaçlı bir döngü ile başlayalım. Java'da bu bir for döngüsüdür; Genel olarak aşağıdaki gibi yazılabilir:

For (başlangıç ​​koşulu; bitiş koşulu; değişiklik) (döngü gövdesi;)

Bu nedenle, 10 kez bir işlem yapmak istiyorsak, aşağıdakileri yazmalıyız:

(int i = 0; i için<10; i++) { System.out.println(i); }

böyle bir program sırayla sıfırdan dokuza kadar sayıları görüntüler. Biraz daha ayrıntılı olarak, basitçe yeni bir i değişkeni oluşturuyoruz ve ona 0'lık bir başlangıç ​​değeri veriyoruz (int i = 0;). Daha sonra döngünün i olduğu sürece yürütülmesi gerektiğini belirtiyoruz.< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).

Pascal'da programlamış olanlar bu fırsatı takdir edeceklerdir:

Int k = 15; for (float i = 0; i

Bu örnekte, i değişkeninin değeri her yinelemede 1,5 artacaktır. Kontrol edebilirsin:).

Sıradaki döngü - süre... Bu, önkoşullu bir döngüdür ve genel olarak şu şekilde yazılabilir:

while (boolean) (eylemler)

Peki, çalışan bir örnek alırsanız, şöyle görünecektir:

iken (bir<10) { System.Out.Print(a); a++; }

Dolayısıyla, hedefe ulaşmak için tam olarak kaç yineleme gerektiğini bilmiyorsanız, ancak hedefinize hangi koşul altında ulaşılacağını tam olarak biliyorsanız, bu döngüyü kullanmanın mantıklı olduğu açıktır. Böyle bir yapı bir kez bile yürütülemez (sonuçta bu, önkoşullu bir döngüdür)! Döngüde eylemlerin kaç kez yürütüleceği, başlangıçta değişkende bulunan değere bağlıdır. a.

Ve üçüncü tür döngüler, bir son koşullu döngülerdir. çok benziyor yaparken sadece eğer yaparken koşul, döngü gövdesi yürütülmeden önce kontrol edilir, ardından döngü gövdesi yürütüldükten sonra koşul kontrol edilir. Bu, koşul kontrol edilmeden önce döngünün en az bir kez yürütüleceği anlamına gelir.