Java’da Döngüler
Bu yazıda sizlere JAVA’da yinelenen işlemlerin gerçekleştirildiği döngülerin neler olduğundan ve nasıl kullanıldığından bahsedeceğim. Genel olarak yazı içerisinde For ve while döngülerini inceleyeceğiz.
JAVA’da kod yazarken kodlarımızın içerisinde yinelenen işlemler olabilir. Örneğin 1’den 10’a kadar olan sayıları ekrana yazdırmak istediğimizi düşünelim. Bu durumda döngü kullanmadan 10 kez system.out.println() fonksiyonunu kullanmamız gerekir. Örnek olarak:
INPUT:
public class Main {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(10);
}
}
OUTPUT:
1
2
3
4
5
6
7
8
9
10Ancak bu işlemi manuel olarak gerçekleştirmek bizim için ideal değildir çünkü kodlarımızı yazarken aynı işlemleri içeren kod satırlarını elle tekrar tekrar yazmamız gerekir. Bu hem zamandan kaybetmemize hem de yazdığımız kodun daha karışık ve uzun hale gelmesine yol açacaktır. Dolayısıyla, hem kodlarımızı daha az çaba harcayarak yazmalıyız hem de daha az kod satırı ile daha çok işlem gerçekleştirebiliyor olmalıyız. Bu sebeple yinelenen işlemlerde döngüleri kullanırız. Döngülerin amacı, aynı veya benzer kodu birkaç kez tekrarlamaktır. Bu tekrarlama belirli bir sayı kadar ya da bir koşul sağlanana kadar sürebilir. JAVA’da iki çeşit döngü mevcuttur. Bunlar for döngüsü ve while döngüsüdür.
İlk olarak while döngüsünden bahsedelim.
WHILE Döngüsü
While döngüsü, döngüde yazdığımız şart doğru olduğu sürece kod bloğu içerisindeki işlemleri gerçekleştirmeye devam eden döngü tipidir. While döngüsü aşağıdaki gibi yazılır:
public class Main {
public static void main(String[] args) {
while (kosul) {
//Yazılan koşulun değeri true ise çalıştıralacak kod bloğu
}
}
}
While döngüsünün kullanımına ilişkin örnekler aşağıdaki gibidir:
INPUT:
public class Main {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("i değeri : " + i);
i += 1;
}
}
}
OUTPUT:
i değeri : 0
i değeri : 1
i değeri : 2
i değeri : 3
i değeri : 4INPUT:
public class Main {
public static void main(String[] args) {
boolean deger = true;
int sonuc = 0;
while (deger == true) {
sonuc += 3;
if(sonuc > 40) {
System.out.println("Limit Değere Aşıldı! Son Değer : " + sonuc);
deger = false;
}
}
}
}
OUTPUT:
Limit Değere Aşıldı! Son Değer : 42
While döngüsünde, koşul doğru ise kod bloğu çalışır. Eğer döngüde yazılan şartın doğru ya da yanlış olduğuna bakılmaksızın kod bloğunun en az bir kez çalıştırılmasını istersek do–while döngüsünü kullanmamız gerekir. Do–while döngüsünün kullanımı ve mantığı while döngüsüne benzerdir. Ancak farkı, şartın durumuna bakmaksızın kod bloğunu bir kez çalıştırır. Do–while döngüsü aşağıdaki gibi yazılır:
public class Main {
public static void main(String[] args) {
do {
//çalıştırılmak istenen kod bloğu
}
while (kosul);
}
}Do–while döngünün kullanımına ilişkin örnek aşağıdaki gibidir:
INPUT:
public class Main {
public static void main(String[] args) {
int toplam = 0;
do{
System.out.println("Toplam : " + toplam);
toplam += 10;
}while(toplam < 100);
}
}
OUTPUT:
Toplam : 0
Toplam : 10
Toplam : 20
Toplam : 30
Toplam : 40
Toplam : 50
Toplam : 60
Toplam : 70
Toplam : 80
Toplam : 90INPUT:
import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
int sayi1, sayi2, i, enBuyuk, enKucuk;
Scanner input = new Scanner(System.in);
System.out.println("Lutfen ilk sayiyi giriniz : ");
sayi1 = input.nextInt();
System.out.println("Lutfen ikinci sayiyi giriniz : ");
sayi2 = input.nextInt();
int k = 2;
i = 2;
enBuyuk = 1;
while(sayi1 >= i){
if((sayi1 % i == 0) && (sayi2 % i == 0)){
enBuyuk = i;
}
i++;
}
enKucuk = (sayi1 * sayi2) / enBuyuk;
System.out.println("En buyuk ortak bolen : " + enBuyuk);
System.out.println("En kucuk ortak bolen : " + enKucuk);
}
}
OUTPUT:
Lutfen ilk sayiyi giriniz :
60
Lutfen ikinci sayiyi giriniz :
70
En buyuk ortak bolen : 10
En kucuk ortak bolen : 420For Döngüsü
For döngüsü, yazılan kod bloğunun istenilen sayı kadar yinelenmesini istediğimiz durumlarda kullanılan döngü tipidir. For döngüsü aşağıdaki gibi yazılabilir:
public class Main {
public static void main(String[] args) {
for (baslangıcDegeri; dongununDevamınıSaglayanSart; ArtısAzalısDegeri) {
//çalıştırılmak istenen kod bloğu
}
}
}For döngüsü yazılırken, döngü içerisindeki ilk alana bir değişken tanımlanır ve başlangıç noktası verilir. Ardından hangi koşul sağlanana kadar döngünün devam etmesi gerektiği yazılır. Son olarak, döngü her sonlandığında, başlangıç noktasından nasıl ilerleme ya da gerileme yapılacağı belirtilir. Bu değerlere göre for döngüsü çalışır ve istenilen işlemleri gerçekleştirir. For döngüsünün kullanımına ait aşağıdaki örnekleri inceleyebiliriz:
INPUT:
public class Main
{
public static void main(String[] args) {
boolean sorgu = true;
for(int i = 2; i <= 100; i++){
for(int k = 2; k < i; k++){
if(i %k == 0){
sorgu = false;
}
}
if(sorgu == true){
System.out.print(" " + i);
}
sorgu = true;
}
}
}
OUTPUT:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97INPUT:
import java.util.Scanner;
class HelloWorld {
public static void main(String[] args) {
int deger, us, sonuc;
Scanner input = new Scanner(System.in);
System.out.print("Lutfen bir deger giriniz : ");
deger = input.nextInt();
System.out.print("Lutfen bir us degeri giriniz : ");
us = input.nextInt();
sonuc = 1;
for(int i = 0; i < us; i++){
sonuc *= deger;
}
System.out.println("Sonuc : " + sonuc);
}
}
OUTPUT:
Lutfen bir deger giriniz : 6
Lutfen bir us degeri giriniz : 2
Sonuc : 36For döngüsü, bir başlangıç noktasından belirtilen koşul altında bir bitiş noktası boyunca belirli bir kod bloğunu tekrar tekrar çalıştırmanın dışında diziler üzerinde de kullanılabilir. Dizi üzerinde yazdığımız for döngüsü, dizinin her bir elemanını dolaşır ve istediğimiz işlemleri dizi elemanları üzerinde gerçekleştirir. Bu tip bir for döngüsünün kullanımı aşağıdaki gibidir:
class HelloWorld {
public static void main(String[] args) {
for (VeriTipi degiskenIsmı : diziIsmı) {
//Çalıştırılması istenen kod bloğu
}
}
}Yukarı yazdığımız for döngüsü tipine ait örnekler aşağıdaki gibidir:
INPUT:
class HelloWorld {
public static void main(String[] args) {
String[] dizi = {"Ahmet", "Mehmet", "Ali","Ayşe","Cansu","Gizem"};
for(String eleman:dizi){
if (eleman == "Ayşe"){
System.out.println("Dizide " + eleman + " elemanına erişildi!");
break;
}
}
}
}
OUTPUT:
Dizide Ayşe elemanına erişildi!Bu yazımızda son olarak while ve for döngüsünde kullanabileceğimiz break ve continue komutlarını kullanışlarından bahsedeceğiz. Break komutunun switch–case yapısında ne amaçla ve nasıl kullanıldığı görmüştük. Döngülerde de break komutunun kullanılma mantığı aynıdır.
Döngü içerisinde belli bir koşul sağlanmışsa ya da belli bir değere geldiğimizde döngünün sonlanmasını isteyebiliriz. Bu durumda döngü içerisinde break komutunu kullanabiliriz. Break komutu çalıştığı anda, döngünün devam etmesi gerekse bile döngüden çıkış yapılacaktır.
Örneğin, içerisinde 4 adet isim olan {“Ahmet”, “Mehmet”, “Ayşe”, “Fatma”} kümesini düşünelim. Bu küme üzerinde bir döngü yazalım. Öyle ki döngü, dizi içerisinde Ayşe ismine uğradığında döngüden çıkış yapsın. Bu döngüyü aşağıdaki gibi yazabiliriz:
INPUT:
public class Main {
public static void main(String[] args) {
String[] isimler = {"Ahmet", "Mehmet", "Ayşe", "Fatma"};
for (String i : isimler) {
if (i == "Ayşe"){
System.out.println("Şu anki değer Ayşe olduğundan döngüden çıkıldı.");
break;
}else{
System.out.println(i);
}
}
}
}
OUTPUT:
Ahmet
Mehmet
Şu anki değer Ayşe olduğundan döngüden çıkıldı.Yukarıda da görüldüğü gibi döngünün uğraması gereken Fatma ismi varken Ayşe’ye denk geldiğinde döngüden çıkıldı ve Fatma ismine hiç uğramadı.
Bu gibi durumlarda döngüden çıkılması istenirse break komutu kullanılabilir.
Continue komutu ise döngünün içerisinde herhangi değere ya da koşula denk gelindiğinde döngünün o basamağını atlamak için kullanılır. Döngü continue çalıştırdığı anda o an ki döngü basamağını atlar ve işlemleri gerçekleştirmeden sonraki döngü adıma geçiş yapar. Sonraki döngü adımında eğer continue’u içeren bloğa girmezse döngü bloğundaki işlemleri gerçekleştirir.
Örneğin, basit olarak 1’den 10’a kadar ekrana yazı yazdırmayı düşünelim. Ekrana bu sayıları yazdırırken 5 sayısının ekrana yazılmadan atlanmasını ve diğer sayıların ekrana yazılmasının devam etmesini isteyelim. Continue komutunu kullanarak bu isteği aşağıdaki gibi gerçekleştirebiliriz:
INPUT:
public class Main {
public static void main(String[] args) {
for(int i = 0; i <= 10; i++){
if (i == 5){
continue;
}
System.out.println(i);
}
}
}
OUTPUT:
0
1
2
3
4
6
7
8
9
10Yazımızı for ve while döngüleri için birkaç örnek daha yaparak sonlandıralım.
INPUT:
import java.util.Scanner;
class HelloWorld {
public static void main(String[] args) {
int deger,toplam, basamak, deger1;
Scanner input = new Scanner(System.in);
System.out.print("Sayi Giriniz : ");
deger = input.nextInt();
deger1 = deger;
toplam = 0;
while (deger1 != 0) {
basamak = deger1 % 10;
toplam += basamak;
deger1 /= 10;
}
System.out.println("Basamaklar toplami : " + toplam);
}
}
OUTPUT:
Sayi Giriniz : 16
Basamaklar toplami : 7INPUT:
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int ilkSayi = 0, ikinciSayi = 1, toplam,deger;
System.out.print("N Sayısını Girin:");
deger = input.nextInt();
System.out.print(ilkSayi+" "+ikinciSayi);
for(int i = 2 ; i < deger + 1; ++i){
toplam = ilkSayi + ikinciSayi;
System.out.print(" "+toplam);
ilkSayi = ikinciSayi;
ikinciSayi = toplam;
}
System.out.println();
}
}
OUTPUT:
N Sayısını Girin:8
0 1 1 2 3 5 8 13 21INPUT:
import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Lutfen kac sayi girilecek? : ");
int n = input.nextInt();
System.out.print("Lutfen deger giriniz : ");
int ilkDeger = input.nextInt();
int enKucuk = ilkDeger;
int enBuyuk = ilkDeger;
for(int i = 0; i < n-1; i++){
System.out.print("Lutfen deger giriniz : ");
int deger = input.nextInt();
if(deger > enBuyuk){
enBuyuk = deger;
}
if(deger < enKucuk){
enKucuk = deger;
}
}
System.out.println("En buyuk deger : " + enBuyuk);
System.out.println("En kucuk deger : " + enKucuk);
}
}
OUTPUT:
Lutfen kac sayi girilecek? : 5
Lutfen deger giriniz : 15
Lutfen deger giriniz : 45
Lutfen deger giriniz : 321
Lutfen deger giriniz : 54
Lutfen deger giriniz : 34
En buyuk deger : 321
En kucuk deger : 15INPUT:
import java.util.Scanner;
class Patika_Java_101 {
public static void main(String[] args) {
int nBitis;
double toplam;
Scanner input = new Scanner(System.in);
System.out.print("Lutfen n sayisinin bitis degerini yaziniz : ");
nBitis = input.nextInt();
toplam = 0;
for(double i = 1; i <= nBitis; i++){
toplam += (1/i);
}
System.out.println("Harmonik Toplam : " + toplam);
}
}
OUTPUT:
Lutfen n sayisinin bitis degerini yaziniz : 6
Harmonik Toplam : 2.4499999999999997JAVA’da dizilerden bahsettiğimiz bir sonraki yazımıza buradan ulaşabilirsiniz.
