10 Eylül
Bölüm 1.9: Java Döngüler (Loops)
Selam Gençler;
Bu yazıda Java'da döngüler konusuna gireceğiz.
Kısaca döngüleri açıklayacak olursak; eğer ki biz e-ticaret sitemizde ürünleri veritabanından çekecek olursak (10000 adet) bunları tek tek alıp elle yazmak yerine 10000 tane adeti döngüye bırakıp böylece ekranda gösterebiliriz. En basit örneğiyle ben size 1 tane "Hello Java" ekrana yazın dediğimde;
System.out.println("Hello Java");böylece yazarsınız ama size 1 milyon tane yazın dersem kopyala yapıştır her şey emek vakit kaybı. Bunu da döngülerde kısaca böyle yapıyoruz;
for(int i = 1;i<=1000000;i++){
System.out.println("Hello Java");
}Görüldüğü üzere ortada 1 milyon adet satır da yok :) Kısaca işimizi kolaylaştırır ve bazı isteklerimizi tek tek koda yazdırma sürecimizdir.
Java'da 4 tip döngü vardır.
- for döngüsü
- while döngüsü
- do-while döngüsü
- foreach döngüsü
Şimdi birinci döngü tipimiz olan for döngüsünden başlayalım.
1) For Döngüsü
Şimdi bizim eğer ki fixed size dediğimiz yani sabit kaç adet bizim döngümüz olacak yani bir ifadeyi kaç defa tekrar edeciğimizi kesin olarak biliyorsak for döngüsünü kullanmak mantıklıdır.Burda biz hem etiketli(labeled) hemde basit bir for döngüsüyle konuyu pekiştireceğiz öncelikle syntaxına bakalım.
for(initialization;booleanExpression;updateStatement){
// code to be executed
}Burda syntaxda görüleceği üzere
- Initialization kısmında bir değişken başlatıyoruz
- boolean expression ile ifadenin doğruluğu kadar kodumuz çalışacaktır
- updateStatement kısmında ise initialization ettiğimiz değişkeni güncelliyoruz.
Basit for-loop
public class Main {
public static void main(String[] args) {
for(int i = 1;i<=10;i++){
System.out.println(i);
}
}
}Görüldüğü üzere 1'den 10'a kadar ekrana yazdırma kodunu yaptık ve eğer ki i 10'dan küçük olduğu sürece ekrana her döngüde i'nin değeri yazılacak ve sonrasında i 1 arttırılacak.
Nested for-loop ( İç İçe for Döngüsü )
Bir de eğer ki for döngümüz iç içe yazılması gerekiyorsa bunu da Nested for-loop ile sağlayabiliriz.
Nested for-loop çarpım tablosu
public class Main {
public static void main(String[] args) {
for(int i = 0;i<=10;i++){
for(int j = 0;j<=10;j++){
System.out.println(i+"x"+j+" ="+(i*j));
}
System.out.println("------");
}
}
}
Bir de etiketli (labeled) for döngümüz vardır.
Labeled for döngüsüne biz bir etiket veririz ve bu etiketi eğer ki nested for loop varsa; etiketi kullanarak ya döngüden çıkarız yada döngüyü devam ettiririz.
public class Main {
public static void main(String[] args) {
labelName:
for(initialization;booleanExpression;updateStatement){
// code to be executed
}
}
}yukarıdaki gibi bir syntax'a sahiptir şimdi bir örnek ile pekiştirelim.
public class Main {
public static void main(String[] args) {
outer_loop:
for (int i = 0; i <= 10; i++) {
inner_loop:
for (int j = 0; j <= 10; j++) {
if (i == 5 && j == 0) {
System.out.println("5'den sonrasına girilmedi ve dış döngüden çıkılıyor");
break outer_loop;
}
System.out.println(i+"x"+j+" ="+(i*j));
}
System.out.println("--------");
}
}
}Görüldüğü üzere outer_loop ile döngüden komple çıkmış oluyoruz.
Eğer ki iç döngüden çıkmak isteseydik inner_loop kullanmamız yeterli olurdu.
2) For-Each Döngüsü
For-each döngüsü J2SE 5.0'da gelen gelişmiş bir döngüdür. Bir array yada collectionların üzerinde gezinmeyi sağlar. for-each döngüsü olarak adlandırılmasındaki ana sebep "for-each = her biri" anlamına geldiği içindir yani her collection yada array elemanını her birini tek tek gezer.
public class Main {
public static void main(String[] args) {
for(data_type instance: array|collection){
// code to be executed
}
}
}Şimdi bir örnek ile pekiştirelim.
public class Main {
public static void main(String[] args) {
int[] myArray = {14,15,12,99};
for(int i : myArray){
System.out.println(i);
}
}
}
14
15
12
99
Şeklinde çıktı alırız görüldüğü üzere her bir elemanın üzerinden giderek her bir elemanı i isimli değişkende tuttuk ve daha sonrasında ekrana yazdırdık.
Şimdi aşağıdaki gibi başka güzel bir örneğe bakalım.
import java.util.List;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
List<String> myJava = new ArrayList<String>();
myJava.add("Java Core");
myJava.add("Java JDBC");
myJava.add("Java JPA/Hibernate");
for(String myLearn : myJava){
System.out.println(myLearn);
}
}
}Java Core
Java JDBC
Java JPA/Hibernate
Gibi bir çıktı alırız.
Şimdi extra bir örnekle bitiriyorum java for-each loopu
public class Main {
public static void main(String[] args) {
List<String> myJava = new ArrayList<String>();
myJava.add("Java Core");
myJava.add("Java JDBC");
myJava.add("Java JPA/Hibernate");
for(java.util.Iterator<String> myLanguage = myJava.iterator();myLanguage.hasNext();){
String value = myLanguage.next();
System.out.println(value);
}
}
}3) While Döngüsü
While döngüsüde diğer döngülerden farksız olarak aynı mantıkta çalışır bir şartı sağlayabilmek için birden fazla döngüye girmesi ve bir şeyi birden fazla tekrar etmesi sürecinde kullanıyoruz.
public class Main {
public static void main(String[] args) {
while(booleanExpression){
// booleanExpression şartı sağlıyorsa ; code to executed
}
}
}while'da görüleceği üzere for döngüsündeki gibi booleanExpression bulunmaktadır yani booleanExpression doğru olduğu sürece bu döngü içerisinde girecek ve çalışacaktır. Şimdi bizim for örneğimizin aynısını buraya alalım.
public class Main {
public static void main(String[] args) {
int i = 1;
while(i<=10){
System.out.println(i);
i++;
}
}
}Görüldüğü üzere dışarıda bir tane i değişkeni tanımladık ve i değeri 10'dan küçük ve eşit olduğu sürece döngü çalışacaktır ve döngünün son ifadesinde biz i'yi her defasında 1 arttırdık eğer ki (i++) olmasaydı döngü sonsuza kadar devam edecekti.
Şimdi Nested While Loop'a bakalım yani iç içe while döngüsü for döngüsünde ki gibi aynı çarpım tablosunu buraya da yapalım.
public class Main {
public static void main(String[] args) {
int i = 0;
while(i <= 10){
int j = 0;
while(j <= 10){
System.out.println(i+"x"+j+"="+(i*j));
j+=1;
}
System.out.println("----------");
i++;
}
}
}Görüldüğü üzere iç içe loop yazıldı şimdi ise Labeled While Loop'a bakalım (Etiketli While Döngüsüne) for döngüsünün aynısıdır.
public class Main {
public static void main(String[] args) {
int i = 0;
outer_loop:
while (i <= 10) {
int j = 0;
inner_loop:
while (j <= 10) {
if (i == 5 && j == 0) {
break outer_loop;
}
System.out.println(i + "x" + j + "=" + (i * j));
j += 1;
}
System.out.println("----------");
i++;
}
}
}4) do-while Loop
do-while döngüsü de genelde ilk durum yani for'da dediğimiz gibi fixed (sabit) bir değer bilmiyorsak başlangıç değeri olarak ne olursa olsun ilk başta döngü dönsün ve daha sonrasında ise koşul ifadesi çalışsın istiyorsak do-while döngüsünü kullanabiliriz.
public class Main {
public static void main(String[] args) {
do{
// code to be executed;
}while(condition);
}
}Şimdi for döngüsündekinin benzerini burda da yapalım.
public class Main {
public static void main(String[] args) {
int i = 1;
do{
System.out.println(i);
i++;
}while(i<=10);
}
}!!! Aşağıdaki örneğe dikkat ediniz lütfen koşul her zaman 2.defasında değerlendirilir önce çalışacak kod olur sonrasında ise condition yani şart değerlendirmesi içerisine girer.
public class Main {
public static void main(String[] args) {
int i = 1;
do{
System.out.println(i);
i++;
}while(i<=0);
}
}Şimdi ise çarpma tablosunu yapalım.
public class Main {
public static void main(String[] args) {
int i=1;
do{
int j = 0;
do {
System.out.println(i+"x"+j+"="+(i*j));
j++;
}while(j<=10);
System.out.println("------");
i++;
}while(i<=10);
}
}
Son olarak da artık labeled (etiketli) do-while'a bakalım bu da aynı mantık sürecinde devam eder.
public class Main {
public static void main(String[] args) {
int i=1;
outer_loop:
do{
int j = 0;
inner_loop:
do {
if (i == 5 && j == 0){
break outer_loop;
}
System.out.println(i+"x"+j+"="+(i*j));
j++;
}while(j<=10);
System.out.println("------");
i++;
}while(i<=10);
}
}5) break Statement (ifadesi)
Break ifadesi bizim programın akışını eğer ki break'i nereye bırakırsak o code bloğunun sonuna getirir ve akış oradan devam etmeye başlar.
Yani bir switch statementi yada döngüden çıkmak için kullanılır.
public class Main {
public static void main(String[] args) {
for(int i = 1;i<10;i++){
if (i==5){
break;
}
System.out.println(i);
}
}
}Şimdi eğer ki i 5 olursa eğer döngüden çıkacaktır ve sadece
1
2
3
4
ekrana yazacaktır.
6) continue Statementi (İfadesi)
continue statementi de eğer ki döngü içerisinde o ifadeye gelirse onu atlamasını ve onunla ilgili bir işlem yapmamasını söyler break ifadesi gibi code bloğunun sonuna gelmez döngüye devam eder.
public class Main {
public static void main(String[] args) {
for(int i = 1;i<10;i++){
if (i==5){
continue;
}
System.out.println(i);
}
}
}
12346789
