Üzerinde kafa patlatmamız gereken, birçok programımız üzerinde önemli etkilere ev sahipliği yapacak diziler kavramını iki parçaya ayırarak anlatmayı düşünüyorum. Bu anlatımım içerisinde Diziler(Arrays) nedir, Dizi boyutları, dizilerin elemanları ile çeşitli sorgulamalar ve işlemlerin bulunacağı bir serüvene çıkacağız.

Java’da Diziler Nedir?

Java’da diziler, birçok programın temel yapısını oluşturan etkili bir kavramdır. Diziler (Arrays), sabit tanımı ile içerisinde aynı türden veri tiplerinin tutulduğu bir yapıdır. Oluşturacağımız ve programız içerisinde kullanacağımız diziler ile veriler daha kolay yöneltilebilir ve gruplandırmalar yapılabilir. Java’da diziler, diğer dillerden farklı olarak bir nesne olarak karşımıza çıkar. Bu sahip olduğu özellik ile daha yüksek bir performans ve bizlere güvenlik sağlar.

Java Dizi Tanımlama

Java’da dizi (array) oluştururken yazacağımız tanımlama şekli şu şekildedir:
veriTipi [] diziAdı = new veriTipi [elemanSayısı];

Şeklinde bir dizi tanımlaması gerçekleştirebiliriz. Programımız için ileride kullanacağımız eleman sayısı belli olmayan bir dizi referansı oluşturmak isteyebiliriz. Bu dizi referansını şu şekilde tanımlayabiliriz:
veriTipi diziAdı[elemanSayısı]; // Örnek: String isimler[];

Java’da nesne olarak oluşturduğumuz diziler kendi içlerinde tekrar çağırabilmemiz için sahip oldukları hafıza adresleri ile birlikte gelmektedir.

Java’da Dizi Boyutları

Java’da dizler iki boyuta ayrılır bunlar;

• Tek Boyutlu Diziler
• Çok Boyutlu Diziler

Bu boyut türleri ile ilerleyen yazılarımızda detaylı örnekler verilecektir ama şuan ki amacımız bir temel oluşturmak.

Java’da Arrays Sınıfı

Oluşturduğumuz dizi elemanlarına ulaşabilmek, karşılaştırma yapabilmek, sıralayabilmek ve çeşitli işlemler için Java kütüphanesinin içerisinde bulunan Arrays sınıfından faydalanarak yapabileceğimiz bazı şeyleri şu şekilde sıralayabilirim:

Dizi Uzunluğuna Nasıl Ulaşırız?

Programlarımızda oluşturduğumuz dizilere veri tabanlarından veri çekebilir ve anlık olarak uzunluğu değişen bir algoritma yazabiliriz. Bu karışıklıkta yazdığımız kodun uzun ömürlü olması ve minimum hata ile karşılaşabilmemiz için length komutunu kullanırız.

// Dizi Tanımlaması:
String [] musteriHavuzu = new String[12741];
// Dizi Uzunluğuna Ulaşmak İçin:
System.out.println(musteriHavuzu.length+" Adet Müşteri Bulundu.");

musteriHavuzu isminde oluşturmuş olduğum dizi içerisinde 12.741 eleman bulunabilir olarak tanımlama yaptım. Bu tanımlama sonucunda dizi eleman sayısı artsa veya azalış gösterse doğru veriyi her zaman alabilmek için musteriHavuzu.length komutunu kullandım.

Dizi (Array) Elemanlarına Erişme

Java’da diziler oluştururken içerisinde bulunan her elemanın bir indis numarası vardır. Dizi içerisinde gerçekleştirmek istediğimiz işlemler için dizi indis numaralarını kullanacağız.

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        int [] diziAdi = new int[3];
        // Dizi İçerisine Eleman Tanımlaması:
        diziAdi[0]=5;
        diziAdi[1]=diziAdi[0]*2;
        diziAdi[2]=(diziAdi[1]-diziAdi[0])*3-2;
        // For Döngüsü İle Dizi İçerisindeki Elemanlara Erişme:
        for(int i=0;i<diziAdi.length;i++){
            System.out.println("Dizinin "+i+".Değeri: "+diziAdi[i]);
        }

    }
}

Kod Çıktısı:

Kod içerisinde 3 eleman bulunacak bir dizi tanımlaması yaptım. Bu elemanlara ulaşabilmemiz ve ekrana yazdırmak için basit bir döngü oluşturarak teker teker dizi indis numaralarına ulaşarak ekrana yazdırma işlemini gerçekleştirdim.

Dizi elemanlarına ulaşmam için gerekli indis numarasını for döngüsü içerisinde bulunan “i” değişkeni sayesinde sağladım. Döngüler konusunda tekrar yapmak isterseniz Java’da döngüler içeriğime göz atabilirsiniz.

Dizi Elemanlarını Sıralama

Programlarımızda kullanıcıdan bazı veriler talep ederek bir dizi oluşturabilir ve bu dizi verilerini küçükten büyüğe sıralamak isteyebiliriz o zaman kullanacağımız komut Arrays.sort(diziAdi); olacaktır.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        int [] karisikVeriler = {7,4,2,6,1,5,3};
        // Dizi Sıralama İşlemi:
        Arrays.sort(karisikVeriler);
        // Dizi Elemanlarını Ekrana Yazdırma:
        for(int i=0;i<karisikVeriler.length;i++){
            System.out.print(karisikVeriler[i]+"\t");
        }
    }
}

Arrays.sort komutunu kullanmak için java.util kütüphanesinden Arrays sınıfını programımıza tanıtmamız gerekiyor.

Dizileri Karşılaştırma

Bir dizi içerisinde bulunan elemanları kopyalama işlemi gerçekleştirmek istiyoruz ve işlem sonucunda doğru kopyalama yapabildiğimizi görmek isteyebiliriz. Bu işlem için kullanacağımız Arrays.Equals metodu ile aynı türde bulunan iki diziyi karşılaştırabiliriz.

// Dizi Tanımlaması:
String [] webSitem = {"www","[dot]","emre","celen","[dot]","com","[dot]","tr"};
String [] webSitem2 = {"www","[dot]","emre","celen","[dot]","com","[dot]","tr"};
if(Arrays.equals(webSitem,webSitem2)==true)
System.out.println("Karşılaştırma Yapılan İki Dizi Birbiri ile Aynı Değerlere Sahip.");
else
System.out.println("Karşılaştırma Yapılan İki Dizi Birbiri ile Aynı Değerlere Sahip Değil.");

Kod Çıktısı:

Örnek olarak verdiğim kod dizisi içerisinde kullandığım if kontrol yapısını kullanmamıza gerek yoktu fakat daha estetik gözükebilmesi ve bize true/false çıktısından farklı bir sonuç vermesi için oluşturduğum kod dizisidir. Normal şartlarda Arrays.equals(diziAdi1,diziAdi2); şeklinde kullanabilirsiniz.

Dizilerde Arama Yapmak

Bu kullanacağımız metot ile aranan elemanın dizi içerisindeki indisi bulunur. Eğer arattığımız eleman dizi içerisinde bulunmuyorsa negatif bir değer döndürür. Örnek olarak yazdığım kod:

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // Değişken Tanımlaması:
        int veriTut,veriAra;
        // Dizi Tanımlaması Gerçekleştirdik:
        int [] myArray = {14,68,74,2,13,69,84};
        Arrays.sort(myArray); // Dizimizi Küçükten Büyüğe Sıraladık.
        System.out.print("Dizi İçerisinde Aramak İstediğiniz Değer: ");
        veriAra=scanner.nextInt();
        veriTut = Arrays.binarySearch(myArray,veriAra);
        System.out.print("-----\n- Dizi Elemanları:");
        for(int i=0;i<myArray.length;i++){
            System.out.print("["+myArray[i]+"]");
        }
        System.out.println("\n-----");
        if(veriTut<0)
            System.out.println("Arama Yaptığınız Değeri Bulamadım.");
        else
            System.out.println("Arama Yaptığınız "+veriAra+" Değeri "+veriTut+" İndisinde Bulunuyor.");
    }
}

Kod Çıktısı:

Yazdığım kod içeriğinde karışık verileri küçükten büyüğe sıralama işlemine tabi tutmasaydım büyük ihtimalle else satırındaki kod dizisini çalıştırarak programı sonlandıracaktı. Sıralama işlemini yaptıktan sonra for döngüsünü kullanarak ekrana dizinin yeni halini yazdırdıktan sonra kullanıcıdan aldığım verinin kaçıncı indiste bulunduğunu veya bulunmadığını ekrana yazdıran if-else kontrol yapısında programı sonlandırıyorum.

Diziyi Listeye Yapısına Dönüştürme

Java’da diziler ekrana yazdırılırken liste şeklinde çıktı vermesini isteyebiliriz bunun için Arrays sınıfının asList() metodunu kullanarak bir liste yapısı oluşturabiliriz.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        Integer [] diziYapisi = {12,13,14,15,16,17,18};
        // Liste Tanımlaması:
        List listeYapisi = new ArrayList();
        // Dizimizi Liste Yapısına Çevirme:
        listeYapisi = Arrays.asList(diziYapisi);
        // Ekrana Yazdırma:
        System.out.println("- Liste Yapısı Yazdırılış Şekli:\n"+listeYapisi);

    }
}

Kod Çıktısı:

Örnek için yazdığım kod içerisinde diziyi asList metodunu kullanarak listeye çevirme işlemini gerçekleştirdim. Bu işlemi yaparken int olarak dizimi oluşturmuş olsaydım bir hata ile karşılaşmayacaktım ama liste yapısında bozukluk meydana gelecekti o yüzden Integer sınıfı üzerinden dizi tanımlamasını gerçekleştirdim.

Dizinin Belli Bir Bölümünü Kopyalama

Tanımladığımız bir diziyi başka bir diziye kopyalayabileceğimiz bir diğer metot ise copyOf() metodudur. Bu metot sayesinde dizimizin istersek tamamını istersek belli bir kısmını başka bir diziye kopyalayabiliriz. Bu metodu kullanırken iki parametre tanımlaması gerçekleştireceğiz. Aldığı ilk parametre kopyalanma işleminin gerçekleşeceği dizidir, ikinci parametre ise dizi üzerinden kaç elemanın kopyalanacağını belirten int türde bir değerdir.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        char [] isimSoyisim = {'E','M','R','E','Ç','E','L','E','N'};
        char [] kopyaDizi ={}; // Kopya İşleminin Gerçekleşeceği Dizi.

        // Asıl Diziyi Ekrana Yazdırma:
        System.out.println("Asıl Dizi Elemanları: ");
        for(int i=0;i<isimSoyisim.length;i++)
            System.out.print(isimSoyisim[i]+" ");

        // Koplanan Dizi Tanımlaması ve Ekrana Yazdırma:
        kopyaDizi = Arrays.copyOf(isimSoyisim,4);
        System.out.println("\nKopyalanan Dizi: ");
        for(int i=0;i<kopyaDizi.length;i++)
            System.out.print(kopyaDizi[i]+"\t");
    }
}

Kod Çıktısı:

Örneğimiz içerisinde bulunan char veri tipinde bir dizi içerisindeki elemanları kopyalamak için oluşturduğumuz diziye kopyalama işlemini gerçekleştirdik.

Peki kopyalanacak eleman sayısı yerine belli bir indis aralığının kopyalanmasını istemiş olsaydık oluşturduğumuz dizi içerisinde o zaman ne kullanacaktık? Sorunun cevabı aslında çok farklı değil bu sefer kullanmamız gereken metot copyOfRange() metodudur.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        int [] asilVeri = {1,4,7,132,62,87,93};
        int [] kopyaVeri={};

        //Asıl Diziyi Ekrana Yazdırma İşlemi:
        System.out.print("-----\n- Asıl Verimiz: ");
        for(int i=0;i<asilVeri.length;i++)
            System.out.print(asilVeri[i]+" ");

        // Kopyalama İşlemi:
        kopyaVeri = Arrays.copyOfRange(asilVeri,0,4);
        System.out.print("\n-----\n- Kopya Veri: ");
        for(int i=0;i<kopyaVeri.length;i++)
            System.out.print(kopyaVeri[i]+" ");
        System.out.println("\n-----");
    }
}

Kod Çıktısı:

Diziye Eleman Atamak

Java’da diziler oluşturulduktan sonra bir bölümüne veya tamamını değiştirerek yeni elemanlar atamak isteyebiliriz. Bu işlemi gerçekleştirebilmek için fill() metodunu kullanacağız.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Dizi Tanımlaması:
        int [] sifirlarDizisi = {0,0,0,0,0};
        int [] birlerDizisi = {1,1,1,1,1};

        // Dizi Elemanlarını Değiştirme:
        Arrays.fill(sifirlarDizisi,1); // Sıfırlar dizi elemanları 1 olarak değiştirildi.
        Arrays.fill(birlerDizisi,1,3,0); // Birler dizi elemanlarından 1 ve 3. indis arasınıdaki değerleri 0 olarak değiştirildi.

        // Ekrana Yazdırma İşlemleri:
        System.out.print ("Değiştirilen Sıfırlar Dizisi: ");
        for(int i=0;i<sifirlarDizisi.length;i++)
            System.out.print("["+sifirlarDizisi[i]+"] ");
        System.out.print("\nDeğiştirilen Birler Dizisi: ");
        for(int i=0;i<birlerDizisi.length;i++)
            System.out.print("["+birlerDizisi[i]+"] ");
    }
}

Kod Çıktısı:

İşlediğimiz konuların bu kısma kadar olan bölümü için bir örnek program oluşturalım. Bu programımız içerisinde 10 elemanlı random değerler alan bir tek boyutlu dizi tanımlaması gerçekleştirelim. Bu oluşturulan dizi elemanlarını önce ekrana yazdıralım ve sonrasında kontrol yapıları oluşturarak dizi elemanlarını büyükten küçüğe yazdıralım.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        // Dizi Tanımlaması:
        int [] randomDizi = new int[10];
        System.out.println("Random Oluşturulan Dizi:\n----------");
        // Diziye Random Değerler Tanımlama:
        for(int i=0;i<randomDizi.length;i++) {
            randomDizi[i] = random.nextInt(100)+1;
            System.out.print("["+randomDizi[i]+"]");
        }
        System.out.print("\n----------\nBüyükten Küçüğe Sıralanmış Hali:\n----------");
        for(int k=1;k<randomDizi.length;k++){
            int saklamaKabi;
            for(int j=0;j<10-k;j++){
                if(randomDizi[j]<randomDizi[j+1]) {
                    saklamaKabi = randomDizi[j];
                    randomDizi[j] = randomDizi[j + 1];
                    randomDizi[j + 1] = saklamaKabi;
                }
            }
        }
        System.out.println("");
        for(int x=0;x< randomDizi.length;x++)
            System.out.print("["+randomDizi[x]+"]");
    }
}

Kod Çıktısı:

Yazdığım kodu tek tek anlatmak istiyorum:
#1 İlk aşamada Random sınıfını programıma tanıttım ve 10 elemanlı bir tek boyutlu dizi tanımlaması gerçekleştirdim.
#2 İkinci aşamada for döngüsü kullanarak dizimin elemanlarına random tanımlamalar gerçekleştirdim ve hepsini aynı döngü içerisinde ekrana yazdırdım.
#3 Üçüncü aşamada basit bir sıralama algoritması kullanarak iki veriyi kontrol yapısına sokabilmem için iki adet for döngüsü oluşturdum. Oluşturduğum ilk döngünün içerisinde saklamaKabi isminde bir değişken oluşturdum ve ikinci döngü içerisinde kontrol yapım içerisinde 0 indisten son indisime kadar kontrol gerçekleştirerek verilerin yerlerini değiştirdim.
#4 Son aşamamda ise sıralama algoritması kullanarak sıraladığım dizimi ekrana yazdırdım ve programı bitirdim.

Çok Boyutlu Diziler

Java’da diziler boyutlarına göre ayrılabildiğini yukarıda oluşturmuş olduğum başlıklarda belirtmiştim. Boyut kavramını şu şekilde anlatabilirim. Bir matris içerisinde satırlar ve sütunlar bulunmaktadır. 4’e 4’lük bir matrisin bütün elemanlarını bir diziye koymak istersek, 2. satırın 1. elemanına erişmek istemiş olsaydık, bu isteğimizi tek boyutlu dizi kullanarak gerçekleştiremezdik.

Java’da çok boyutlu dizileri şu şekilde tanımlarız:
int diziAdi[][] = new int [elemanSayisi][elemanSayisi];

Çok boyutlu dizilere biraz daha farklı olacak şekilde 5 öğrencisi bulunan özel bir sınıfın öğrenci isimleri ve not ortalamalarını gireceğimiz bir çok boyutlu dizi tanımlaması yapalım.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        // Değişken Tanımlaması:
        int not;
        // Çok Boyutlu Dizi Tanımlaması:
        Object ozelSinif[][] = new Object[5][2];
        String ogrenciAdi[] = {"Emre","Ömer","Mert","Ali İhsan","Metehan"};

        for(int i=0;i<5;i++){
            not=random.nextInt(100)+1;
            ozelSinif[i][1]=not;
        }
        for(int k=0;k<5;k++)
            ozelSinif[k][0] = ogrenciAdi[k];

        for(int x=0;x<5;x++){
                System.out.println("Öğrenci İsmi: "+ozelSinif[x][0]+" Öğrencinin Notu: "+ozelSinif[x][1]);
        }
    }
}

Kod Çıktısı:

#1 Yazdığım kod içerisinde hem int hem String bir ifade tutacağım için öncelikle Object türünde çok boyutlu bir dizi oluşturdum.
#2 Öğrenci notlarını random atayabilmek için random sınıfını tanımladım.
#3 Oluşturduğum dizinin ilk [x][0] alanına öğrenci isimlerini, [x][1] kısımlarına ise öğrenci notlarını girmek istediğimden dolayı gerekli döngü tanımlamalarını yaptım.
#4 Son olarak ekrana çıkan sonucu yazdırabilmek için son bir döngü ile ekrana yazdırma işlemini gerçekleştirdim.

Bir konun daha sonuna geldik. Kısa sürede güzel ilerleme kat ettiğimizi düşünüyorum ama bu süreçte aklınıza takılan bir soru veya bir öneriniz varsa her zaman belirttiğim gibi aşağıda benimle “yorum yap” kısmından iletişime geçerek bildirebilirsiniz.