Bölüm 9: Diziler ve Cok Boyutlu Veri Yapilari

9.1 Tek Boyutlu Dizilere Giriş

Diziler, aynı türden birden fazla veriyi tek bir değişken altında saklamamızı sağlayan temel veri yapılarıdır. Java’da diziler, sabit boyutlu ve aynı veri tipindeki elemanları ardışık bellek bölgelerinde tutar.

💡 Pedagojik Kutu: Dizileri, bir apartmanın daireleri gibi düşünebilirsiniz. Her daire (eleman) aynı büyüklükte ve aynı yapıda, ancak farklı numaralara (indeks) sahip.

Dizi Bildirimi ve Başlatma Yöntemleri

// Dizi bildirimi
int[] sayilar; // Önerilen yöntem
int sayilar2[]; // Alternatif yöntem (C tarzı)

// Dizi oluşturma ve başlatma
sayilar = new int[5]; // 5 elemanlı dizi (tüm elemanlar 0)
int[] notlar = {85, 90, 78, 92, 88}; // Doğrudan başlatma

Dizi Elemanlarına Erişim ve İndeksleme

Dizi indeksleri 0’dan başlar. dizi[0] ilk elemanı, dizi[uzunluk-1] son elemanı temsil eder.

int[] dizi = {10, 20, 30, 40, 50};
System.out.println(dizi[0]); // 10
System.out.println(dizi[4]); // 50

Dizi Uzunluğu ve Sınır Kontrolü

Her dizi length özelliğine sahiptir. Dizi sınırlarının dışına çıkmak ArrayIndexOutOfBoundsException hatasına yol açar.

// FarklıVeriTipleri.java
public class FarkliVeriTipleri {
    public static void main(String[] args) {
        // Farklı veri tiplerinde dizi tanımlama
        int[] tamSayilar = {1, 2, 3, 4, 5};
        double[] ondalikliSayilar = {1.5, 2.7, 3.14};
        String[] isimler = {"Ali", "Ayşe", "Mehmet"};
        char[] harfler = {'A', 'B', 'C'};
        
        // Dizi elemanlarına erişim
        System.out.println("İlk tam sayı: " + tamSayilar[0]);
        System.out.println("Son ondalıklı sayı: " + ondalikliSayilar[ondalikliSayilar.length - 1]);
        System.out.println("İkinci isim: " + isimler[1]);
        
        // Dizi uzunluğunu kullanma
        System.out.println("Tam sayı dizisi uzunluğu: " + tamSayilar.length);
        
        // Sınır kontrolü örneği
        if (harfler.length > 3) {
            System.out.println("4. harf: " + harfler[3]);
        } else {
            System.out.println("Dizi 3. indekse sahip değil!");
        }
    }
}

9.2 Tek Boyutlu Dizi İşlemleri

Dizilerle çalışırken en sık kullanılan işlemler okuma, yazma, kopyalama ve birleştirmedir.

Dizi Elemanlarını Okuma ve Yazma

int[] dizi = new int[5];
dizi[0] = 100; // Yazma
int deger = dizi[0]; // Okuma

Dizi Üzerinde Döngü Kullanımı

int[] sayilar = {1, 2, 3, 4, 5};

// For döngüsü ile
for (int i = 0; i < sayilar.length; i++) {
    System.out.println(sayilar[i]);
}

// For-each döngüsü ile (sadece okuma için)
for (int sayi : sayilar) {
    System.out.println(sayi);
}

Dizi Kopyalama ve Klonlama

int[] kaynak = {1, 2, 3, 4, 5};
int[] hedef = new int[kaynak.length];

// Yöntem 1: Manuel kopyalama
for (int i = 0; i < kaynak.length; i++) {
    hedef[i] = kaynak[i];
}

// Yöntem 2: System.arraycopy()
System.arraycopy(kaynak, 0, hedef, 0, kaynak.length);

// Yöntem 3: clone() metodu
int[] klon = kaynak.clone();

Dizi Birleştirme ve Dilimleme

int[] dizi1 = {1, 2, 3};
int[] dizi2 = {4, 5, 6};

// Birleştirme
int[] birlestirilmis = new int[dizi1.length + dizi2.length];
System.arraycopy(dizi1, 0, birlestirilmis, 0, dizi1.length);
System.arraycopy(dizi2, 0, birlestirilmis, dizi1.length, dizi2.length);

// Dilimleme (belirli aralığı kopyalama)
int[] dilim = Arrays.copyOfRange(kaynak, 1, 4); // {2, 3, 4}

// DiziIslemleri.java
public class DiziIslemleri {
    public static void main(String[] args) {
        // Dizi elemanlarını toplama ve ortalama hesaplama
        int[] notlar = {85, 90, 78, 92, 88, 76, 95};
        int toplam = 0;
        
        for (int not : notlar) {
            toplam += not;
        }
        
        double ortalama = (double) toplam / notlar.length;
        System.out.println("Toplam: " + toplam);
        System.out.println("Ortalama: " + ortalama);
        
        // İki diziyi birleştirme
        int[] dizi1 = {1, 2, 3, 4, 5};
        int[] dizi2 = {6, 7, 8, 9, 10};
        
        int[] birlestirilmis = new int[dizi1.length + dizi2.length];
        System.arraycopy(dizi1, 0, birlestirilmis, 0, dizi1.length);
        System.arraycopy(dizi2, 0, birlestirilmis, dizi1.length, dizi2.length);
        
        System.out.print("Birleştirilmiş dizi: ");
        for (int eleman : birlestirilmis) {
            System.out.print(eleman + " ");
        }
        System.out.println();
        
        // Belirli bir aralığı kopyalama
        int[] kaynak = {10, 20, 30, 40, 50, 60, 70};
        int[] dilim = new int[3];
        System.arraycopy(kaynak, 2, dilim, 0, 3);
        
        System.out.print("Dilim (indeks 2-4): ");
        for (int eleman : dilim) {
            System.out.print(eleman + " ");
        }
    }
}

9.3 Dizi Tabanlı Algoritmalar

Diziler, birçok temel algoritmanın uygulanması için ideal veri yapılarıdır.

Doğrusal Arama Algoritması

Dizide belirli bir elemanı baştan sona kadar sırayla arar.

İkili Arama Algoritması

Sadece sıralı dizilerde çalışır. Diziyi ortadan ikiye bölerek arama yapar.

⚠️ Pedagojik Kutu: İkili arama, telefon rehberinde isim ararken kullandığımız yönteme benzer. Ortadaki sayfayı açıp aradığımız ismin önünde mi arkasında mı olduğuna bakarız.

// DogrusalArama.java
public class DogrusalArama {
    public static int ara(int[] dizi, int hedef) {
        for (int i = 0; i < dizi.length; i++) {
            if (dizi[i] == hedef) {
                return i; // Eleman bulundu, indeksini döndür
            }
        }
        return -1; // Eleman bulunamadı
    }
    
    public static void main(String[] args) {
        int[] sayilar = {34, 12, 56, 78, 23, 45, 67, 89};
        int aranan = 45;
        
        int sonuc = ara(sayilar, aranan);
        if (sonuc != -1) {
            System.out.println(aranan + " sayısı " + sonuc + ". indekste bulundu.");
        } else {
            System.out.println(aranan + " sayısı dizide bulunamadı.");
        }
    }
}

// KabarcikSiralama.java
public class KabarcikSiralama {
    public static void sirala(int[] dizi) {
        int n = dizi.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (dizi[j] > dizi[j + 1]) {
                    // Swap işlemi
                    int temp = dizi[j];
                    dizi[j] = dizi[j + 1];
                    dizi[j + 1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] sayilar = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.print("Sıralanmamış dizi: ");
        for (int sayi : sayilar) {
            System.out.print(sayi + " ");
        }
        System.out.println();
        
        sirala(sayilar);
        
        System.out.print("Sıralanmış dizi: ");
        for (int sayi : sayilar) {
            System.out.print(sayi + " ");
        }
    }
}

9.4 Çok Boyutlu Dizilere Giriş

Çok boyutlu diziler, matris ve tablo gibi yapıları temsil etmek için kullanılır.

İki Boyutlu Diziler: Matris Kavramı

İki boyutlu dizi, satır ve sütunlardan oluşan bir tablo yapısıdır.

// 3x3 matris tanımlama
int[][] matris = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Satır ve Sütun İndekslerini Anlama

dizi[satir][sutun] şeklinde erişilir. Her iki indeks de 0’dan başlar.

// MatrisOrnegi.java
public class MatrisOrnegi {
    public static void main(String[] args) {
        // 3x3 matris tanımlama
        int[][] matris = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // Matris elemanlarına erişim
        System.out.println("Matrisin 1. satır, 2. sütunu: " + matris[0][1]);
        System.out.println("Matrisin 3. satır, 3. sütunu: " + matris[2][2]);
        
        // Matrisi yazdırma
        System.out.println("\nMatris:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(matris[i][j] + " ");
            }
            System.out.println();
        }
        
        // İki boyutlu dizi ile tablo oluşturma
        String[][] ogrenciler = {
            {"Ali", "85", "90"},
            {"Ayşe", "92", "88"},
            {"Mehmet", "78", "95"}
        };
        
        System.out.println("\nÖğrenci Not Tablosu:");
        System.out.println("İsim\tVize\tFinal");
        for (String[] ogrenci : ogrenciler) {
            for (String bilgi : ogrenci) {
                System.out.print(bilgi + "\t");
            }
            System.out.println();
        }
    }
}

Üç ve Daha Fazla Boyutlu Diziler

// 3 boyutlu dizi (2x3x4)
int[][][] ucBoyutlu = new int[2][3][4];

9.5 Çok Boyutlu Dizi İşlemleri

İç İçe Döngülerle Dizi Tarama

int[][] matris = new int[3][4];
for (int i = 0; i < matris.length; i++) {
    for (int j = 0; j < matris[i].length; j++) {
        matris[i][j] = i + j;
    }
}

Matris Toplama ve Çıkarma

Aynı boyutlardaki matrislerin karşılıklı elemanları toplanır/çıkarılır.

// MatrisToplama.java
public class MatrisToplama {
    public static void main(String[] args) {
        int[][] matris1 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        int[][] matris2 = {
            {9, 8, 7},
            {6, 5, 4},
            {3, 2, 1}
        };
        
        int[][] toplam = new int[3][3];
        
        // Matris toplama
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                toplam[i][j] = matris1[i][j] + matris2[i][j];
            }
        }
        
        System.out.println("Toplam Matris:");
        for (int[] satir : toplam) {
            for (int eleman : satir) {
                System.out.print(eleman + " ");
            }
            System.out.println();
        }
    }
}

Matris Çarpımı

Matris çarpımında, birinci matrisin sütun sayısı, ikinci matrisin satır sayısına eşit olmalıdır.

// MatrisCarpimi.java
public class MatrisCarpimi {
    public static void main(String[] args) {
        int[][] matris1 = {
            {1, 2, 3},
            {4, 5, 6}
        };
        
        int[][] matris2 = {
            {7, 8},
            {9, 10},
            {11, 12}
        };
        
        int satir1 = 2, sutun1 = 3;
        int satir2 = 3, sutun2 = 2;
        
        int[][] carpim = new int[satir1][sutun2];
        
        // Matris çarpımı
        for (int i = 0; i < satir1; i++) {
            for (int j = 0; j < sutun2; j++) {
                for (int k = 0; k < sutun1; k++) {
                    carpim[i][j] += matris1[i][k] * matris2[k][j];
                }
            }
        }
        
        System.out.println("Çarpım Matrisi:");
        for (int[] satir : carpim) {
            for (int eleman : satir) {
                System.out.print(eleman + " ");
            }
            System.out.println();
        }
    }
}

Transpoz Alma İşlemi

int[][] matris = {{1, 2}, {3, 4}, {5, 6}};
int[][] transpoz = new int[2][3];

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        transpoz[j][i] = matris[i][j];
    }
}

9.6 Düzensiz Diziler (Jagged Arrays)

Düzensiz diziler, her satırın farklı uzunlukta olabildiği çok boyutlu dizilerdir.

Düzensiz Dizi Bildirimi ve Başlatma

// Düzensiz dizi bildirimi
int[][] jagged = new int[3][];
jagged[0] = new int[4];
jagged[1] = new int[2];
jagged[2] = new int[5];

// JaggedArrayOrnegi.java
public class JaggedArrayOrnegi {
    public static void main(String[] args) {
        // Farklı uzunlukta satırlara sahip düzensiz dizi oluşturma
        int[][] ogrenciNotlari = new int[3][];
        ogrenciNotlari[0] = new int[]{85, 90, 78}; // 3 sınav
        ogrenciNotlari[1] = new int[]{92, 88}; // 2 sınav
        ogrenciNotlari[2] = new int[]{76, 95, 82, 89}; // 4 sınav
        
        // Düzensiz dizi elemanlarına erişim
        System.out.println("Öğrenci Notları:");
        for (int i = 0; i < ogrenciNotlari.length; i++) {
            System.out.print("Öğrenci " + (i + 1) + ": ");
            for (int j = 0; j < ogrenciNotlari[i].length; j++) {
                System.out.print(ogrenciNotlari[i][j] + " ");
            }
            System.out.println();
        }
        
        // Düzensiz dizi ile çok boyutlu dizi karşılaştırması
        System.out.println("\nSatır uzunlukları:");
        for (int i = 0; i < ogrenciNotlari.length; i++) {
            System.out.println("Satır " + i + " uzunluğu: " + ogrenciNotlari[i].length);
        }
    }
}

9.7 Gelişmiş Dizi Uygulamaları

Dizi Tabanlı Yığın (Stack) Veri Yapısı

Yığın, LIFO (Last In First Out) prensibiyle çalışan bir veri yapısıdır.

// DiziStack.java
public class DiziStack {
    private int[] dizi;
    private int ust;
    private int kapasite;
    
    public DiziStack(int boyut) {
        dizi = new int[boyut];
        kapasite = boyut;
        ust = -1;
    }
    
    public void push(int eleman) {
        if (ust == kapasite - 1) {
            System.out.println("Stack dolu!");
            return;
        }
        dizi[++ust] = eleman;
    }
    
    public int pop() {
        if (bosMu()) {
            System.out.println("Stack boş!");
            return -1;
        }
        return dizi[ust--];
    }
    
    public boolean bosMu() {
        return ust == -1;
    }
    
    public static void main(String[] args) {
        DiziStack stack = new DiziStack(5);
        
        stack.push(10);
        stack.push(20);
        stack.push(30);
        
        System.out.println("Çıkarılan: " + stack.pop());
        System.out.println("Çıkarılan: " + stack.pop());
    }
}

Çok Boyutlu Dizilerle Görüntü İşleme Temelleri

Gri tonlamalı görüntüler, iki boyutlu dizilerle temsil edilir.

// GriGoruntu.java
public class GriGoruntu {
    public static void main(String[] args) {
        // 4x4 gri tonlamalı görüntü (0-255 arası değerler)
        int[][] goruntu = {
            {255, 200, 150, 100},
            {200, 150, 100, 50},
            {150, 100, 50, 0},
            {100, 50, 0, 0}
        };
        
        System.out.println("Gri Tonlamalı Görüntü:");
        for (int[] satir : goruntu) {
            for (int piksel : satir) {
                System.out.printf("%4d", piksel);
            }
            System.out.println();
        }
        
        // Görüntüyü ters çevirme (negatif)
        System.out.println("\nNegatif Görüntü:");
        for (int i = 0; i < goruntu.length; i++) {
            for (int j = 0; j < goruntu[i].length; j++) {
                System.out.printf("%4d", 255 - goruntu[i][j]);
            }
            System.out.println();
        }
    }
}

9.8 Performans ve Bellek Yönetimi

Dizilerin Bellek Yerleşimi

Java’da diziler heap bellekte saklanır. Tek boyutlu dizilerde elemanlar ardışık olarak yerleşir.

Satır-Öncelikli ve Sütun-Öncelikli Erişim

Çok boyutlu dizilerde erişim düzeni, performansı önemli ölçüde etkiler.

// ErisimPerformansi.java
public class ErisimPerformansi {
    public static void main(String[] args) {
        int boyut = 1000;
        int[][] matris = new int[boyut][boyut];
        
        // Matrisi doldur
        for (int i = 0; i < boyut; i++) {
            for (int j = 0; j < boyut; j++) {
                matris[i][j] = i + j;
            }
        }
        
        // Satır-öncelikli erişim (daha hızlı)
        long baslangic = System.nanoTime();
        int toplam1 = 0;
        for (int i = 0; i < boyut; i++) {
            for (int j = 0; j < boyut; j++) {
                toplam1 += matris[i][j];
            }
        }
        long satirSuresi = System.nanoTime() - baslangic;
        
        // Sütun-öncelikli erişim (daha yavaş)
        baslangic = System.nanoTime();
        int toplam2 = 0;
        for (int j = 0; j < boyut; j++) {
            for (int i = 0; i < boyut; i++) {
                toplam2 += matris[i][j];
            }
        }
        long sutunSuresi = System.nanoTime() - baslangic;
        
        System.out.println("Satır-öncelikli erişim süresi: " + satirSuresi + " ns");
        System.out.println("Sütun-öncelikli erişim süresi: " + sutunSuresi + " ns");
        System.out.println("Performans farkı: %" + 
            ((double)(sutunSuresi - satirSuresi) / satirSuresi * 100));
    }
}

Dizi İşlemlerinde Zaman Karmaşıklığı Analizi

İşlem	Zaman Karmaşıklığı
Elemana erişim	O(1)
Doğrusal arama	O(n)
İkili arama (sıralı dizi)	O(log n)
Kabarcık sıralama	O(n²)
Matris toplama	O(n×m)
Matris çarpımı	O(n³)

9.9 Özet

Bu bölümde, Java’da tek ve çok boyutlu dizi kullanımını, dizi işlemlerini ve dizi tabanlı algoritmaları öğrendik. Diziler, temel veri yapıları olarak programlamanın vazgeçilmez bir parçasıdır ve birçok algoritmanın temelini oluşturur.

9.10 Temel Terimler

Dizi (Array): Aynı türden birden fazla veriyi saklayan veri yapısı
İndeks (Index): Dizi elemanlarına erişmek için kullanılan sayısal değer
Matris: İki boyutlu dizi yapısı
Düzensiz Dizi (Jagged Array): Her satırı farklı uzunlukta olan çok boyutlu dizi
Yığın (Stack): LIFO prensibiyle çalışan veri yapısı

9.11 Sorular

Java’da bir dizinin uzunluğunu nasıl öğrenebiliriz?
İki boyutlu bir dizide satır sayısını ve sütun sayısını nasıl buluruz?
Düzensiz dizi ile normal çok boyutlu dizi arasındaki fark nedir?
Doğrusal arama ile ikili arama arasındaki temel farklar nelerdir?
Matris çarpımı işleminde hangi koşul sağlanmalıdır?

9.12 Alıştırmalar

10 elemanlı bir tamsayı dizisi oluşturun ve bu dizinin en büyük ve en küçük elemanını bulan bir program yazın.
İki 3x3 matrisin çarpımını hesaplayan bir program yazın.
Bir metin dosyasındaki kelime sayısını bulan bir program yazmak için dizi kullanın.
Düzensiz bir dizi oluşturun ve her satırdaki elemanların ortalamasını hesaplayın.
Bir diziyi ters çeviren (ilk eleman sona, son eleman başa gelecek şekilde) bir algoritma yazın.

9. Sinif ve Nesne Yapisi