Ana içeriğe atla

Java Diziler (Arrays)


Diziler objedir , dizi objesi içinde belli sayıda değişken bulundurur .Eğer bu sayı sıfır ise dizimiz boş demektir.Dizinin içersindeki değişkenlere isimleri ile değil , negatif olmayan tam sayı ile ifade edilen dizi erişim indeks(gösterge) ile erişilir. Dizi içersindeki değişkenler dizinin elemanlarıdır.Eğer bir dizide n tane eleman varsa dizinin uzunluğuda n kadardır diyebiliriz . Dizi içersindeki ilk elemanın konumu 0 'dan başlar , son elemanın yeri ise n-1 'dir.
Dizi içersindeki her elemanın tipi aynı olmak zorundadır. Eğer dizi içersindeki bir elemanın tipi double ise , bu dizinin tipi için double diyebiliriz.Bu double tipinde olan diziye String tipinde bir obje atmayı denersek , hata ile karşılaşırız. Dizilerimiz ilkel tipdeki veya herhangi bir obje tipindeki elemanlardan oluşabilirler.

Dizi tipindeki değişkenler

Dizi tipindeki değişkenler objeye bağlanmaktadır.Dizi tipinde değişken tanımlamak , dizimizi hemen kullanacağımız anlamına gelmez.
gösterim-12
double[] dd  ; // double tipindeki dizi
double dd[] ;  // double tipindeki dizi
float [] fd ;  // float tipindeki dizi
Object[] ao ;  // Object tipindeki dizi

Gösterim-12 de sadece dizi objelerine bağlanacak olan değişkenleri tanımladık. Bu dizi objelerimiz hafıza alanında henüz yer kaplamamışlardır. Dizi objelerini oluşturmak için new anahtar kelimesini kullanmamız gereklidir.

Dizileri oluşturmak

Dizilerimize , herhangi bir obje oluşturuyormuş gibi oluşturabiliriz.
gösterim-13
double[] d = new double[20] ; // 20 elemanlı double tipindeki dizi
double dd[] = new double[20]; // 20 elemanlı double tipindeki dizi
float [] fd = new float [14]; // 14 elemanlı float tipindeki dizi
Object[] ao  = new Object[17]; // 17 elemanlı Object tipindeki dizi
String[] s = new String[25] ;  // 25 elemanlı String tipindeki dizi  
örneğin new double[20] ifadesi ile 20 elemandan oluşan double dizisi elde etmiş olduk.

Dizilerin tekrardan boyutlandırılması

Dizilere bir kere boyutları verildi mi , artık değiştirilemezler.
gösterim-14
int  liste[] = new int[5] ;
liste = new int[15] ; // yeni bir dizi objesine baglandi
Gösterim-14' de dizimizin boyutlarını büyüttüğümüzü sanmayın , sadece yeni bir dizi objesi daha oluşturduk. liste dizi değişkeninin daha evvelden bağlanmış olduğu dizi objesi ( new int[5] ) , çöp toplama işlemi sırasında çöp toplayıcısı (garbage collector ) tarafından hafızadan silinecektir.

Dizi içersindeki elemanlara ulaşım

Java dilinde dizi kullanımının diğer dillere nazaran daha az risklidir. Bunun anlamı ,eğer tanımladığımız dizinin sınırlarını aşarsak, çalışma-anı (runtime) hatasını java bize çekinmeden vereceğidir.
.Örneğin 20 lik bir double dizisi tanımladık eğer bu dizinin 78. elemana ulaşmak istersek(- ki böyle bir indeks de böyle bir eleman yok) , olanlar olur ve çalışma-anı hatasını alırız . Bu çalışma-anı hatasının verilmesi aslında güzel bir olaydır, böylece Java dizi için ayrılmış hafıza alanından dışarı çıkıp , başka verilere mudahale etmemize engeller.
ör-dizi-1
public class DiziElemanlariGosterimBir {
    
 
    public static void main(String args[]) {
        double[] d  = { 2.1 , 3.4 , 4.6 ,1.1 ,0.11 } ; 
        String[]  s  = { "defter" ,"kalem" , "sarman" ,"tekir" ,"boncuk" }; ;       
 
        // double tipindeki dizimizi ekrana bastiriyoruz 
        for (int i = 0 ; i < d.length ; i ++) {
            System.out.println("d["+i+"] = " + d[i] );
            // System.out.println("d["+78+"] = " + d[78] ); // ! Hata !
        }
        System.out.println("---------------");
        // String tipindeki dizimizi ekrana bastiriyoruz 
        for (int x = 0 ; x < s.length ; x ++) {
            System.out.println("s["+x+"] = " + s[x] );
            // System.out.println("s["+78+"] = " + s[78] );  // ! Hata ! 
        }
    } 
}
length ifadesi ile bir dizinin içersindeki eleman sayısını öğreniriz.Bu örneğimizde iki adet dizi tanımladık , double ve String tipindeki dizilerimiz içersine 5'er adet eleman yerleştirdik ve sonradan bunları for döngüsü ile ekrana bastırdık. i < d.length ifadesine dikkat ederseniz , döngü sayacımız 4'e kadar işlemektedir ama döngü sayacamız 0'dan başladığını unutmayalım.Bunun sebebi dizilerin 0 dan başlamalarıdır , unutmaması gereken bir ayrıntı.
Eğer 5 eleman'a sahip olan dizilerimizin 78. elemanına erişmeye kalkışırsak , derleme anında (compile-time) bir hata ile karşılaşmayız ama uygulamamızı çalıştırdığımız zaman yani çalışma-anında (runtime) hata ile karşılaşırız.
Uygulamamızın çıktısı aşağıdaki gibidir.
d[0] = 2.1
d[1] = 3.4
d[2] = 4.6
d[3] = 1.1
d[4] = 0.11
---------------
s[0] = defter
s[1] = kalem
s[2] = sarman
s[3] = tekir
s[4] = boncuk
Aynı örneğimizi daha değişik sekilde ifade edebiliriz.
ör-dizi-2
public class DiziElemanlariGosterimIki {
 
    double[] d ; 
    String[]  s  ;                  
 
    public  DiziElemanlariGosterimIki() {
        // double tipindeki dizimize eleman atiyoruz
        d = new double[5];
        d[0] = 2.1 ;
        d[1] = 3.4  ;
        d[2] = 4.6 ;
        d[3] = 1.1 ;
      d[4] = 0.11 ;
        // d[5] = 0.56 ; //  ! Hata ! 
 
        // String  tipindeki dizimize eleman atiyoruz
        s = new String[5] ;
        s[0] = new String("defter");
        s[1] = new String("kalem");
        s[2] = new String("sarman");
        s[3] = new String("tekir");
        s[4] = new String("boncuk");
        // s[5] = new String("duman"); // ! Hata ! 
    }
 
    public void ekranaBas() {
        // double tipindeki dizimize ekrana bastiriyoruz 
        for (int i = 0 ; i < d.length ; i ++) {
            System.out.println("d["+i+"] = " + d[i] );
        }
        System.out.println("------------------------");
        // String tipindeki dizimize ekrana bastiriyoruz 
        for (int x = 0 ; x < s.length ; x ++) {
            System.out.println("s["+x+"] = " + s[x] );
        }
    }
 
    public static void main(String args[]) {
           DiziElemanlariGosterimIki deg = new DiziElemanlariGosterimIki();
           deg.ekranaBas();
    }
}
Bu örneğimizde , 5 eleman kapasitesine sahip olan dizilerimize , 6. elemanı ekleye çalıştığımız zaman , derleme esnasında (compile-time) herhangi bir hata ile kaşılaşmayız. Ne zaman ki uygulamamızı çalıştırdığımızda , Java taradından çalışma-anı (runtme) hatasını alırız.Fakat hatali satirlar kapali olduğu için uygulamamız sorunsuz bir şekilde çalışmaktadır.
Uygulamamızın çıktısı aşağıdaki gibidir.
d[0] = 2.1
d[1] = 3.4
d[2] = 4.6
d[3] = 1.1
d[4] = 0.11
------------------------
s[0] = defter
s[1] = kalem
s[2] = sarman
s[3] = tekir
s[4] = boncuk

Diziler içersinde elemanların sıralanması

Diziler içersindeki elemanlarımızı büyükten küçüğe doğru sıralatmak için , java.util paketinin altındaki Arrays sınıfını kullanabiliriz. Bu sınıfın sort() metodu sayesinde dizilerin içersindeki elemanlar kolaylıkla sıralanırlar.
ör-eleman-sıralama
import java.util.*; // java.util kutuphanelerini kullanmak icin
 
public class DiziSiralama {
 
    public static void ekranaBas(double[] d) {
        for (int i = 0 ; i < d.length ; i++) {
            System.out.println("d["+i+"] = " + d[i]);
        }
    }
 
    public static void main(String args[]) {
        double d[] = new double[10] ;
        d[0] = 2.45 ;
        d[1] = 3.45 ;
        d[2] = 4.78 ;
        d[3] = 1.45 ;
        d[4] = 15.12 ;
        d[5] = 1 ;
        d[6] = 9 ;
        d[7] = 15.32 ;
        d[8] = 78.17 ;
        d[9] = 4.58 ;
        System.out.println("Karisik sirada");
        ekranaBas(d); 
        Arrays.sort( d ) ;
        System.out.println("Siralanmis Sirada");
        ekranaBas(d);
    }
}
Uygulamamızın çıktısı aşağıdaki gibidir.
Karisik sirada
d[0] = 2.45
d[1] = 3.45
d[2] = 4.78
d[3] = 1.45
d[4] = 15.12
d[5] = 1.0
d[6] = 9.0
d[7] = 15.32
d[8] = 78.17
d[9] = 4.58
Siralanmis Sirada
d[0] = 1.0
d[1] = 1.45
d[2] = 2.45
d[3] = 3.45
d[4] = 4.58
d[5] = 4.78
d[6] = 9.0
d[7] = 15.12
d[8] = 15.32
d[9] = 78.17

Dizilerin dizilere kopyalanması

Eğer elimizde uygun iki dizi var ise bunları birbirlerine kopyalıyabiliriz.
ör-dizilerin kopyalanması
public class DizilerinKopyalnmasi {
 
    public static void main(String args[]) {
        // ilk dizimiz
        int[] dizi1 = { 1,2,3,4 } ;
        // daha genis olan 2. dizimiz
        int[] dizi2 = { 100 , 90 , 78 , 45 ,40 , 30 , 20 ,10} ;
        // kopyalama islemini baslatiyoruz
        // 0. indeksten dizi1 uzunlugu kadar kopyalama yap
        System.arraycopy(dizi1,0,dizi2,0,dizi1.length);
        for (int i = 0 ; i < dizi2.length ; i++) {
            System.out.println("dizi2["+i+"] = "+ dizi2[i] );
        } 
    }
}
System sınıfının statik bir metodu olan arraycopy() sayesinde dizi1'i dizi2'ye kopyaladık.Burada dikkat edilmesi gereken konu ,arraycopy() metodu tarafından kopyalanan dizi objelerinin kendisi değil,dizi objelerin referanslarıdır.Uygulamamızın çıktısı aşağıdaki gibidir .
dizi2[0] = 1
dizi2[1] = 2
dizi2[2] = 3
dizi2[3] = 4
dizi2[4] = 40
dizi2[5] = 30
dizi2[6] = 20
dizi2[7] = 10

Çok Boyutlu Diziler

Java programlama dilindeki çok boyutlu diziler , diğer programlama dillerindekilerden farklıdır.Sonuçta dizinin tek tipte olma şartı vardır , yani dizi içersinde diziler ( dizilerin içersinde dizilerin içersindeki diziler .......) tanımlıyabilirsiniz.
gösterim-15
  int[][] t1 = {
 
     { 1, 2, 3, },
 
     { 4, 5, 6, },
 
  };
Gösterim-15 'de ifade edildiği gibi , iki vektörlü (bukleli parantezler ile belirtilmiş), ilkel tipten oluşmuş çok boyutlu dizi oluşturabilirsiniz.
Çok boyutlu dizileri oluşturmanın diğer bir yolu .
gösterim-16
int [] [] t1 = new int [3][4] ;
int [] [] t1 = new int [][4]  ;  // ! Hata ! 
ör-çok-boyutlu-1
public class CokBoyutluDizilerOrnekBir {     
 
    public static void main(String args[]) {
         int ikiboyutlu[][] = new int[3][4] ;
         ikiboyutlu[0][0] = 45 ;
         ikiboyutlu[0][1] = 83 ;
         ikiboyutlu[0][2] = 11 ;
         ikiboyutlu[0][3] = 18 ;
 
         ikiboyutlu[1][0] = 17 ;
         ikiboyutlu[1][1] = 56 ;
         ikiboyutlu[1][2] = 26 ;
         ikiboyutlu[1][3] = 79 ;
 
         ikiboyutlu[2][0] = 3 ;
         ikiboyutlu[2][1] = 93 ;
         ikiboyutlu[2][2] = 43 ;
         ikiboyutlu[2][3] = 12 ;
 
         // ekrana bastiriyoruz
         for (int i = 0 ; i<ikiboyutlu.length ; i++  ) {
             for (int j = 0 ;  j < ikiboyutlu[i].length ; j++ ) {
                System.out.println(" ikiboyutlu["+i+"]["+j+"] =" + ikiboyutlu[i][j] );
             }
         } 
     }
}
Yukarıdaki örneğimizde int ilkel tipinde 3'e 4 lük çok boyutlu dizi oluşturduk veya 3'e 4'lük bir matris gibi de düşüne biilirsiniz. Uygulanın çıktısı aşağıdaki gibidir.
ikiboyutlu[0][0] =45
ikiboyutlu[0][1] =83
ikiboyutlu[0][2] =11
ikiboyutlu[0][3] =18
ikiboyutlu[1][0] =17
ikiboyutlu[1][1] =56
ikiboyutlu[1][2] =26
ikiboyutlu[1][3] =79
ikiboyutlu[2][0] =3
ikiboyutlu[2][1] =93
ikiboyutlu[2][2] =43
ikiboyutlu[2][3] =12
Uygulamamızın çıktısını matris gibi düşünürsek.
45 83 11 18
17 56 26 79
3 93 43 12
Uygulamamızı şekil olarak gösterirsek

Şekil 6

Çok boyutlu dizilerde , dizilere bağlı dizilerin aynı boyutta olma zorunluluğu yoktur.
ör-çok-boyutlu-2
public class CokBoyutluDiziler {
 
     public static void main(String args[]) {
        int ikiboy[][] = new int[3][]; 
 
        ikiboy[0] = new int[2] ; 
        ikiboy[1] = new int[1] ; 
        ikiboy[2] = new int[3] ;       
 
        ikiboy[0][0] = 89 ;
        ikiboy[0][1] = 32 ;    
 
        ikiboy[1][0] = 5 ;
        // ikiboy[1][1] = 3 ;  // ! Hata !    
 
        ikiboy[2][0] = 55 ;
        ikiboy[2][1] = 78 ;
        ikiboy[2][2] = 49 ; 
     } 
}
Yukarıdaki örneğimizde görüldüğü üzere , dizilere bağlı her dizinin boyutları birbirinden farklı olmuştur.Şekil üzerinde ifade etmeye çalışırsak.


Şekil-7
Çok boyutlu dizilerin içersine Obje tipileride yerleştirmemiz mümkündür.Örneğin String tipinden oluşmuş çok boyutlu dizi oluşturulmuş olsun :
ör-çok-boyutlu-3
public class HayvanlarAlemi {
 
    String isimler[][][]  ;  
 
    public HayvanlarAlemi() {
           isimler = new String[2][2][3] ;
           veriAta();
    }
 
    public void veriAta() {
         isimler[0][0][0] = "aslan" ;
         isimler[0][0][1] = "boz AyI" ;
         isimler[0][0][2] = "ceylan";
 
         isimler[0][1][0] = "deniz AnasI" ;
         isimler[0][1][1] = "essek" ;
         isimler[0][1][2] = "fare"  ;
 
 
         isimler[1][0][0] = "geyik" ;
         isimler[1][0][1] = "hamsi" ;
         isimler[1][0][2] = "inek" ;
 
 
 
         isimler[1][1][0] = "japon baligi" ;
         isimler[1][1][1] = "kedi" ;
         isimler[1][1][2] = "lama" ;
 
       ekranaBas() ;
 
    }
 
 
 
    public void ekranaBas() {
        for (int x = 0 ; x < isimler.length ; x++) {
            for (int y = 0 ; y < isimler[x].length ; y++) {
               for (int z = 0 ; z < isimler[x][y].length ; z ++) {
                   System.out.println("isimler["+x+"]["+y+"]["+z+"]  =" + isimler[x][y][z]);
               }
            }
        }
    }
 
    public static void main(String args[]) {
        HayvanlarAlemi ha = new HayvanlarAlemi();
    } 
}

Bu örneğimizde HayvalarAlemi objesinin new oluşturulması ile olaylar tetiklenmektedir.İster tek boyutlu olsun ister çok boyutlu olsun , diziler üzerinde işlem yapmak istiyorsak onları oluşturmamız gerektiğini daha evvelden belirtmiştik. Bu örneğimizde olduğu gibi dizimizi ilk oluşturduğumuzda dizi içersindeki String objelerinin ilk değeri null dır.Uygulamamızın çıktısı aşağıdaki gibidir.
isimler[0][0][0] =aslan
isimler[0][0][1] =boz AyI
isimler[0][0][2] =ceylan
isimler[0][1][0] =deniz AnasI
isimler[0][1][1] =essek
isimler[0][1][2] =fare
isimler[1][0][0] =geyik
isimler[1][0][1] =hamsi
isimler[1][0][2] =inek
isimler[1][1][0] =japon baligi
isimler[1][1][1] =kedi
isimler[1][1][2] =lama
Oluşan olayları şekil üzerinde göstermeye çalışırsak

Şekil-7

Bölüm Sonu

Bu bölümde , objeleri oluşturulmadan evvel yapılandırıcı metodların çağrıldığını ve bu yapılandırıcı metodlar sayesinde , objelerimiz ilk posizyonlarını aldıklarını öğrendik.Uygulamalarda objelerin ilk posizyonlarına getirilmesi büyük bir önem taşımaktadır.Objeleri oluşturmak kadar , gereksiz oldukları zaman da hafızadan silmenin önemli olduğu bir gerçektir.Java kullanılmayan objelerin silinmesini kodu yazan kişiye bırakmamaktadır.Javanın aktif olarak kullandığı 3 adet çöp toplama yöneteminin olduğunu bu bölümde inceledik.
Ayrıca değişkenlerin çeşitlerine deyindik , global obje değişkeni , global statik değişken,ve yerel değişken.Bunların arasındaki farkları iyi bilmek çok önemlidir.Statik ve statik olmayan metodların ne zaman tanımlanması gerektiği uygulamalarda büyük bir önem teşkil etmektedir.
Sorular
  1. (aklınıza gelen bu konular ile ilgili güzel sorular varsa lütfen bildiriniz)



Yorumlar

Bu blogdaki popüler yayınlar

Java Deger Atama ve Local Değişkenler

Değişkenlereilk değerlerini atama Javauygulamalarında üç tür değişken çeşiti bulunur , yerel (local) değişkenler, obje'ye ait global değişkenler ve son olarak sınıfa aitglobal değişkenler(statik değişkenler). Bu değişkenlerin tipleri ilkel(primitive) veya herhangi bir obje tipi olabilir. ör-javada-degiskenler public class DegiskenGosterim {int x ; //objeye ait global degiskenstatic int y ; // sınıfa ait global degiskenpublic void metod () {int i ; //yerel degisken//static int y = 5 ;// yanlis}} Yerel(local)değişkenlerYereldeğişkenlere kesin olarak ilk değerleri kodu yazan kişi tarafındanverilmelidir. İlk değeri verilmeden kullanılan yerel değişkenlere uyarı ,derleme(compile-time) anında verilir. gösterim-11 public int hesapla () { // yerel değişkenlere ilk değerleri her zaman verilmelidir.int i ; i++; // ! Hata ! ilk deger verilmeden üzerinde işlem yapılamazreturn i ;} Objeyeait global değişkenlerObjelereait global değişkenler'e ilk değerlerini kodu kişi vermek zorunda değildir.Ja…

Anakart ve Bileşenleri Nelerdir?

Anakart
Mainboard olarak da adlandırılır. Sistemdeki bütün kartların, işlemcinin üzerine takıldığı, diğer donanım aygıtlarının kablolar vasıtasıyla bağlandığı ve bilgisayarın en karmaşık parçalarından biridir.
Anakart Bileşenleri
1. İşlemci soketi: İşlemcinin takıldığı sokettir.
2. Bellek soketi: RAM denilen sistem belleğinin takıldığı soketdir.
3.Genişleme Yolları Anakart üzerine ekran kartı, modem, ses kartı, vs gibi parçalar anakart üzerindeki genişleme yuvaları ya da veri yolu yuvaları denilen soketlere takılır. Yani kartların işlediği veriler ve kartlara giden bilgiler, bu yuvalar ve anakart üzerindeki veri yolları aracılığı ile işlemciye ve diğer aygıtlara ulaşırlar.
4. Güç Konnektörleri(Güç kaynağı girişi): Anakart üzerine güç kaynağından gelen kablolar bu konnektörlere bağlanır.
5. Klavye/Fare Konnektörleri(portları): Klavye ve fare yuvarlak 6 pinli bir fiş (PS/2 fişi) kullanılarak anakartaki klavye ve fare portlarına bağlanır.
6. Yonga Setleri (Chipsets): Bilgisayarların trafik pol…

Aktif Güç Nedir,Reaktif Güç Nedir

Aktif Güç Nedir? , Reaktif Güç Nedir?



Direnç tipi bir yük gerilim kaynağından gerilimin çarpanı şeklinde bir akım çekmektedir, ancak reaktif yüklerin çektiği akım direnç yükündeki gibi değildirReaktif yüklerde de hem gerilim hem de akım dalga şekilleri sinüzoidal olabilir ancak aralarında bir faz farkı vardırReaktif yüklerde bir periyot süresince akım ve gerilim işaretleri aynı veya farklı olabilir
Akım ve gerilim işaretinin farklı olduğu noktalarda güç negatiftir ve güç akışı kullanıcıdan şebekeye doğrudurŞebekeden çekilen bu enerji kullanılmadan şebekeye geri verilir ve bu dolaşım sırada iletim hatlarındaki dirençlerden dolayı kayıplar oluşurYani reaktif güç şebekeyle yük arasında salınan ancak kullanılmayan enerjidirAşağıdaki şekilde açık gölgelendirilmiş bölgeler reaktif gücün, koyu gölgelendirilmiş bölgeler ise aktif gücün söz konusu bölgeleri göstermektedir

Aktif enerji şebeke periyodu boyunca şebekeden çekilen enerjidir, bu da gerilimle akımın çarpımının zaman ekseninin üstünde k…