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)