Pure Java – 45 Loops

Merhaba Arkadaslar,
Bu yazimda Java da dongu(loop) yapilarindan bahsedecegim. Evet bir cok dilde bu yapi zaten benzer yapida calismaktadir. Konu akisi geregi bu bolumu de isleyecegim, donguler konusundan sonra daha keyifli konulara yavas yavas gececegiz.

Burada anlatacagim ek detaylar, oneriler ve sinavda dikkat edilmesi gereken noktalar yine de faydali olacaktir.

while dongusu
while dongu yapisi genel olarak , dongunun kac defa dondugunu bilmedigimiz durumlarda faydali olabilir.

while dongusu genel formati ;

while(expression){
// do something
}

Burada expression boolean bir sonuc olmalidir. while dongusu bu expression sonucunun true oldugu surece calisacaktir.

expression kisminda kullanilacak degiskenimiz , while dongusunden once tanimlanmis olmasi gereklidir. Yani ;

while(int x=2; x<3) { } //derleme hatasi verecektir.

while dongusune hic girilmeyebilir. Eger expression ilk durumda false degere sahipse , donguye girilmeden atlanacaktir.

public class LoopTest1 {
	public static void main(String[] args) {
		int x = 5;
		while (x > 5) {
			System.out.println("dongu icerisi");
		}
		System.out.println("dongu disi");

	}
}


do-while dongusu

do-while dongusu while dongusune benzer , fark olarak expression kontrolu dongunun sonunda yapilir.

Genel format ;

do {
//do something
}while(expression)

do-while dongusunde ,expression kontrolu do-while dongusunun sonunda yapilacagi icin do-while dongusu en azindan 1 kez calisacaktir.

do{
    System.out.println("dongu ici");
}while(false); 
//sinavda noktali virgul(;) un olup olmadigina 
//dikkat etmek gerek

Sinavda dikkat edilmesi gereken bir kac ifade;

int x=1;
while(x){} //derleme hatasi , x boolean tipinde degil
while(x=5) {} //derleme hatasi , atama operatoru
while(x==5){} //gecerli bir expression
while(true){} //gecerli bir expression


for dongusu

Java 6 ile itibaren for dongusune yeni bir yapi geldi. Bunlar ;

  • basic for loop(temel for dongusu)
  • enhanced foor loop(gelistirilmis for dongusu)

temel for dongusu
for dongusu en cok kullanilan dongu yapisidir. Ozellikle dongunun kac defa calisacagi biliniyorsa bu dongu yapisi kullanilmaktadir. for dongusunun 3 bolumden olusur ;

  • degiskenlerin tanimlanmasi(declaration) ve deger atanmasi(initialization)
  • kontrol ifadesi(boolean expression)
  • tekrarlama ifadesi(iteration expression)

for dongusu genel formati;

for(Initialization ; Condition ; Iteration) {
//
}

for dongusunun , initialization kisminda 0 veya daha fazla ayni tipte degiskeni tanimlayip deger atamasinda bulunabiliriz.

for (int x = 10, y = 5 , z=20; x < 15; x++) {
}

Degisken tanimlama ve deger atama kismi for dongusune girmeden once calisacaktir. Bu kisim for dongusunde sadece bir kez en basta calisacaktir.

Sinavda dikkat edilmesi gereken noktalardan birisi, degiskenlerin scope/kapsam alanina dikkat etmek gerekir.

for(int x=1; x<5; x++){
    System.out.println(x);
} 
System.out.println(x); //derleme hatasi, scope/kapsam disi

initialization kismindan sonra , condition kismi calisacaktir.
Bu kisim boolean deger olmalidir. Burada dikkat edilmesi gereken nokta ; en fazla 1(bir) logical expression(mantiksal ifade) olabilir fakat bu logical expression karisik/complex olabilir.

for (int x = 0, y = 5; ((x < 5 && y > 3) | x == 1); x++) {

}

Yukaridaki for dongusu derleme hatasi vermez fakat bu for dongusunde derleme hatasi olacaktir;

for(int x=1,y=5; (x>5),(y<3); x++ ) {

}

Sinavda dikkat edilmesi gereken nokta: sadece bir tane test expression (ifadesi) olabilir.  Diger bir deyisle birden fazla test kontrolunu  virgul ile ayirip for dongusunde kullanamayiz.

for dongusunun govdesi calisip sonlandiktan sonra iteration kismi calisacaktir.Yani iteration kismi for dongusunde en son olarak calisacaktir.

for dongusunde bu uc kisimda zorunlu degildir. Yani bu for dongusu sorunsuzca sonsuza kadar calisir.

for (;;) {
System.out.println("Sonsuz Dongu");
}

for dongusu initialization ve iteration kismi olmadan while dongusu gibi kullanilabilir. Burada ; isaretlerine dikkat etmek gerekir.

int i = 0;
for (; i < 10;) {
    i++;
    //
}

Tekrar etmekte fayda var.Sinavda variable scope/degisken yasam alani/kapsam alani onemli.

int x = 3;
for (x = 12; x < 20; x++) {
System.out.println(x);
}
System.out.println(x); 
//x for dongusunden once tanimlandigi icin kapsam alani
//burada da gecerli olacaktir.

 

for (int x = 12; x < 20; x++) {
    System.out.println(x);
}
System.out.println(x); 
// x for dongusunde tanimlandigi icin bu noktada 
//x degiskeninin kapsam alani gecerli olmayacaktir 
//ve derleme hatasi verecektir.

Son bir ek olarak , for dongusundeki bu 3 kisim birbirinden bagimsizdir. Yani bu uc kisimda ayni degiskenlerin kullanilmasina gerek yoktur. Bununla birlikte Iteratin kisminda her zaman increment operatoru gormeye aliskiniz , fakat boyle olmaz zorunda degildir. Yani;

int b=3;
for(int a=1; b!=1; System.out.println("iterate")) {
    b=b-a;
    System.out.println("for-ici");
}


gelistirilmis for dongusu
Gelistirilmis for dongusu(enhanced for loop) Java 6 ile birlikte geldi. Gelistirilmis for dongusu , array ve collection yapilarinda kolaylik saglayan bir yapiya sahiptir.

Gelistirilmis for dongusu genel formati;

for(declaration : expression)

ornek olarak;

// temel for dongusu
int a[] = { 1, 2, 3, 4 };
for (int x = 0; x < a.length; x++) {
    System.out.println(a[x]);
}

//gelistirilmis for dongusu
for(int n:a){
    System.out.println(n);
}
public class LoopTest {
	public static void main(String[] args) {

		int[] intArray = { 1, 2, 3, 4 };
		Integer[] wrapperIntArray = { 1, 2, 3, 4 };

		for (int x : intArray)
			System.out.println(x);

		for (Integer x2 : intArray)
			System.out.println(x2);

		for (int x3 : wrapperIntArray)
			System.out.println(x3);
		for (Integer x4 : wrapperIntArray)
			System.out.println(x4);

	}
}

Gelistirilmis for dongusunde kullandigimiz dizinin tipi ile, “declaration” kisminda kullandigimiz degiskenin tipi uyumlu olmalidir.

long[] longArray = { 1, 2, 3, 4 };
Long[] wrapperLongArray = { 1L, 2L, 3L, 4L };

for (Long x4 : longArray)
System.out.println(x4);

for (int x5 : longArray) //derleme hatasi , 
System.out.println(x5); 
//long veya Long tipindeki dizi icin "declaration" kisminda 
//int tipinde degisken kullanamayiz.

Bir diger dikkat edilmesi gereken nokta ,”declaration” kisminda kullanilan degiskenin daha once tanimlanmis olmamasi gerekmekedir.

int x5=0; 
for(x5:intArray) //derleme hatasi
System.out.println(x5);

Gelistirilmis for dongusunde primitive tipleri kullanabilecegimiz gibi referans tipte elemanlar iceren dizileri de kullanabiliriz.

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

public class TestAnimal {
	public static void main(String[] args) {
		Animal[] animalArray = { new Dog(), new Cat(), new Cat() };
		Dog[] dogArray = { new Dog(), new Dog(), new Dog() };

		for (Animal d : animalArray) {
		}

		// for (Dog d2 : animalArray) { // derleme hatasi
		// }

		for (Dog d3 : dogArray) {

		}
	}
}

Daha fazla kod ornegini size birakiyorum , bol miktar kod yazmak faydali olacaktir.

Yazimi burada sonlandiriyorum.
Herkese Bol Javali Gunler dilerim.
Be an oracle man , import java.*;
Levent Erguder
OCP, Java SE 6 Programmer
injavawetrust

Print Friendly, PDF & Email

Leave a Reply

Your email address will not be published. Required fields are marked *