Eclipse

1. Package Explorer ekranında jar dosyasını oluşturmak istediğimiz projeye sağ tıklıyoruz. Açılan menüden Export seçeneğine tıklıyoruz.
   
2. Açılan ekranda Java altında JAR File seçeneğini seçerek Next diyoruz.
   
3. Açılan ekranda, istenilen proje ve paketleri seçiyoruz. Alttaki seçeneklerde, oluşturulan class dosyalarını ve kaynakları eklemek için “Export generated class files and resources” seçeneğini, kaynak dosyaları eklemek için “Export java source files and resources” seçeneğini seçiyoruz. JAR File bölümünde jar dosyasını oluşturmak istediğimiz yeri seçiyoruz. Seçenekler kısmında, eğer jar dosyasını sıkıştırmak istiyorsak “Compress the contents of jar file” seçeneğini, dizinlendirmelerin olduğu gibi eklenmesini istiyorsak “Add directory entries” seçeneğini, herhangi bir uyarı vermeden eski jar dosyası üzerine yazmak istiyorsak “Overwrite existing files without warning” seçeneğini seçiyoruz ve Next diyoruz.
   
4. Açılan ekranda, Next diyoruz.
   
5. Açılan ekranda, eğer manifest dosyasının otomatik yaratılmasını istiyorsak, “Generate manifest file” seçeneğini, kendi oluşturduğumuz manifest dosyasını eklemek istiyorsak, “Use existing manifest from workspace” seçeneğini seçerek manifest dosyasının yerini seçiyoruz. Eğer, projemiz bir kütüphane değil de çalıştırılabilir bir uygulama olacak ise “Main class” seçeneğinden uygulamanın hangi sınıfdan başlayacağını seçiyoruz (sınıfın main metoduna sahip olması gerekiyor).
   

Not: İşlemler Eclipse 4.2 Juno versiyonunda gerçekleştirilmiştir.

Netbeans

Netbeans’te işlemler biraz daha kolay ama seçenekler de Eclipse’e göre daha az.

1. Projects ekranında jar dosyasını oluşturmak istediğimiz projeye sağ tıklıyoruz. Açılan menüden Properties seçeneğine tıklıyoruz.
   
2. Açılan ekranda Build > Packaging‘e tıklıyoruz. Sağ tarafta “JAR File” kısmında dosyanın oluşacağı klasör belirtiliyor (proje klasörünün altında). “Exclude From JAR File” kısmında jar dosyasına eklemek istemediğimiz dosyaları yazıyoruz. Örnekte, tüm java ve form uzantılı dosyalara eklenmeyecek şekilde seçim yapılmış. Eğer, jar dosyasını sıkıştırmak istiyorsak, “Compress JAR file” seçeneğini, eğer proje derlendikten sonra jar dosyasının otomatik olarak oluşmasını istiyorsak (bu örnekte bu şekilde oluşturacağız), “Build JAR after Compiling” seçeneğini, eğer kullandığımız kütüphaneleri de jar dosyasına eklemek istiyorsak, “Copy dependent libraries” seçeneğini seçerek OK‘ye tıklıyoruz.
   
3. Projects ekranında jar dosyasını oluşturmak istediğimiz projeye sağ tıklıyoruz. Açılan menüden Clean and Build seçeneğine tıklıyoruz. Bu işlemden sonra jar dosyası “proje yolu/dist/” klasörü altında oluşmuş oluyor.
   

Not: İşlemler Netbeans 7.0.2 versiyonunda gerçekleştirilmiştir.

Herkese iyi çalışmalar.

Sun microsystem’de Java dilini ve dolayısıyla da virtual machine (sanal makine) yi icad etti. Her zaman benzer bir felsefe ile çalışırdı, Geliştirdiği şeyler her zaman virtual machine üzerinde idi.

Sun Microsystems’in 2010 da Oracle tarafından alınmasından sonra, Oracle  ile patent mevzuları vb sebeplerden ayrı düştüler. Bİr süre Google için çalıştı. Şimdilerde de Scala adlı bir firma için danışman olarak görev alıyor.

Yazmış olduğu dil Java ile, dünyada “bir kere yaz, her yerde kullan” devri başladı. Java’nın bu özelliği onu çok fazla tercih edilebilir kılacaktı. Ayrıca günümüzdeki IDE’lerin (IDE : Integrated Developement Engine, Entegre Yazılım Geliştirme Uygulaması) de atası olacaktı.

Günümüzde İyi bir yazılımcı istiyorsak, Java bilen bir kişiyi, herhangi bir konuda eğitmek için tercih edebiliyoruz. Hem yazılım düzeni, hem de OOP konusunda gerçekten mecburen düzgün geliştirilen bir dilden bahsediyorum..

Burada Java ve Gosling hakkında bir slideshow bulabilirsiniz.

JAR dosya formatının birçok avantajı vardır. Bunlar:

• Java uygulamaları doğrudan (Windows jargonunda exe uzantılı çalıştırılabilir dosyalar gibi) çalıştırılabilir hale gelmektedir.
• Uygulama indirirken (özellikle applet uygulamalarında) tek bir dosya indirme avantajı vardır.
• ZIP özelliğinden dolayı Java uygulamalarının boyutlarının küçülmesini sağlar.
• Java uygulamasının versiyon bilgilerinin tutulmasını sağlar.
• Java’nın en temel özelliği olan platform bağımsızlığı sayesinde tek dosya farklı platformlarda çalışabilir.
• Dijital olarak imzalanabilme özelliği sayesinde güvenlik de sağlamış olur.
• ZIP özelliğinden dolayı kolaylıkla çözülerek içerisindeki dosyalara erişilebilir.
• Kolaylıkla kütüphane dosyaları oluşturulabilmesini sağlar.

Başka bir yazıda da Java uygulamamızdan nasıl JAR dosyası yaratabileceğimizi anlatmaya çalışacağım. Herkese kolay gelsin.

Aslında konunun başlığı genel anlamda konuyu özetliyor (en azından sadece bir kısmını :)). Java 1.5 versiyonuyla gelen Generics özelliği, yazdığımız sınıfı tipler üzerinde soyutlaştırmamızı, türden bağımsız sınıflar yaratabilmemizi sağlıyor. Yani, sınıfı yazarken sınıfın metotlarının birden fazla tip için çalışabilirliğini sağlamış oluyoruz.

En güzel anlatım örnekle anlatımdır diyerek (tamamen kendi görüşüm :)) bir örnek üzerinde gösterelim. Örneğin, ArrayList sınıfı. Aslında 1.2 versiyonundan beri Generics özelliğinden mahrum olarak Java’da mevcut bir sınıf. İçerisinde tüm nesneleri tutabilen bir liste. İçerisinden istenilen tipi barındırabilmek ilk bakışta çok cazip gelse de aslında çok sakat(!) bir işlem. Bu konuya daha sonra değineceğim. Burada sadece örnek veriyorum.

Apple anApple = new Apple();
Pear aPear = new Pear();
       
ArrayList ourBag = new ArrayList();
ourBag.add(anApple);
ourBag.add(aPear);

Görüldüğü üzere elma ile armutu bir araya koyduk. ArrayList sınıfının eski halinde add metodu Object tipinde parametreye sahip olduğu için iki nesneyi de ekleyebildik.

add (Object o);

Şimdi de kendimizi biraz kısıtlayalım. Generics özelliğini kullanalım.

ArrayList<Apple> ourAppleBag = new ArrayList<Apple>();
ourAppleBag .add(anApple);
ourAppleBag .add(aPear); // Dikkat: derleyici izin vermez.

Oops. ArrayList‘in yanında Apple nesnesi var. Artık çantamıza sadece elma atabilir hale geldik (3. satıra derleyici izin vermeyecektir). Eğer, armutlarımızı tutmak istiyorsak yeni bir çanta almamız lazım.

ArrayList<Pear> ourPearBag = new ArrayList<Pear>();

Peki ne oldu? Neden birden kısıtladık kendimizi? Ayrıca türden bağımsızlık işin neresinde? Metodun parametresini Object türünde yaparsak tüm tipteki nesneleri alabilir değil mi artık?

Nimetler, Nimetler, Nimetler

Öncelikle elmayla armut aynı çantada olursa neler olur onu görelim. Parametre olarak bir ArrayList alan metodumuz olduğunu düşünelim.

getAppleJuice (ourBag);
// ...
public void getAppleJuice(ArrayList bag) {
        Apple anApple = bag.get(0);
}

Bu metodu derlemek istediğinizde derleyici hata vererek sizden cast işlemi yapmanızı isteyecektir. Çünkü;

Object get (int index);

get metodu Object tipinde bir nesne döndürüyor.

getAppleJuice (ourBag);
// ...
public void getAppleJuice(ArrayList bag) {
        Apple anApple = (Apple) bag.get(0);
}

Artık derleyici bize kızmıyor. Ama her zaman içinde elma olduğunu nereden bileceğiz. Şu durumu düşünelim;

getAppleJuice (ourBag);
// ...
public void getAppleJuice(ArrayList bag) {
        Apple anApple = (Apple) bag.get(1);
}

Derleyici için bir sorun yok. Programı çalıştırabilirsiniz. Hatta müşterinize satabilirsiniz. Bir süre sonra müşteriniz size elma suyu yerine armut suyu içtiğini, programın bozuk olduğunu söylerse şaşırmayın.

Gerçekte olan ise, programın çalışması anında Java bize kızar ve bir exception fırlatır. Buyrun size en güzelinden bir böcek.

E o zaman ArrayList sınıfına müdahele edelim ve Object olan yerleri Apple‘a çevirelim. Artık, getAppleJuice metodunun elma suyu döndürmesini garantilemiş olduk. Peki armutları tutmak için ne yapacağız? ArrayList sınıfını kopyalayacağız ve tüm Object olanları Pear yapacağız. Meyveler arttıkça kopya sınıflar da artmış oldu. Yeni her tip için sınıfı tekrar yazacağız.

Bu dertten kurtulmak gerekir. Bir kere yazalım hepsi için program anında bile düzgün çalışsın. Üstelik sadece 1 sınıfla!

Generics ile yazılmış ArrayList sınıfı ArrayList<E> şeklinde tanımlanıyor. Artık nesnesini oluştururken hangi sınıfı verirsek çantaya o nesneyi atabileceğiz. Yeni add metodu;

add (E e);

şeklinde. Artık parametre çanta yaratırken belirttiğimiz E tipinde.

ArrayList<Apple> ourAppleBag = new ArrayList<Apple>();
ourAppleBag.add(anApple);

Artık, çantamız bir elma çantası ve armut almıyor. Armut alan çanta için armut çantası yaratacağız.

Şimdi elma suyu metodumuza yeniden bakalım;

getAppleJuice (ourAppleBag);
// ...
public void getAppleJuice(ArrayList<Apple> bag) {
        Apple anApple = bag.get(1);
}

Biraz kısıtladık kendimizi değil mi? Ama program çalışırken ortaya çıkacak sürprizlerden kurtarmış olduk kendimizi. Artık metod aldığı çantanın bir elma çantası olduğunu biliyor. Cast işlemine de ihtiyaç duymuyor.

Sonuç?

Bu tarz her yazımda olduğu gibi yazının sonunda öneride bulunayım:

• Halihazırdaki Java sınıflarını (özellikle ArrayList gibi Collection türündeki sınıfları) kullanırken Generics halini kullanın. Hatta diğer hali hiç kullanmayın
• Eğer, kendi yazdığınız sınıf birden fazla tip için çalışacaksa tek ve doğru yolunuz Generics şeklinde yazmak.

Öncelikle, mevcut durumda neler oluyor görmek için Java’nın mevcut sınıflarının print metodunda nasıl gözüktüğüne bir göz atalım.

// Öncelikle bilinen birkaç sınıftan nesne yaratalım
Integer int1 = new Integer(10);
Double double1 = new Double(25.36);
int arr[] = {1, 2, 4};
ArrayList list = new ArrayList();
list.add(3);

// Bu nesneleri konsola yazdıralım
System.out.print("int1: ");
System.out.println(int1);
System.out.print("double1: ");
System.out.println(double1);
System.out.print("arr: ");
System.out.println(arr);
System.out.print("list: ");
System.out.println(list);

Yukarıdaki kod parçasın bilinen birkaç Java sınıfının nesnelerini konsola yazdırıyor. Konsol çıktısı;

int1: 10
double1: 25.36
arr: [I@42e816
list: [3]

Ben konsola yazdırmak istemiyorum programımın içerisinde String olarak kullanmak istiyorum diyenler için bir örnek;

String listStr = list.toString();

Bu örnek aslında konunun özünü vermiş oldu. Evet, Java’da ister mevcut sınıflar, ister kendi tanımladığımız sınıflar olsun, kullandığımız her sınıf bir toString metoduna sahip. Metodun kaynağı ise her sınıfın en tepesindeki ata sınıfı olan Object sınıfı. toString metodu kalıtımsal olarak tüm sınıflara taşınıyor.

Bazı sınıflar toString metodunu kendince yeniden düzenlerken, bazı sınıflar hiç değiştirmeden Object sınıfının toString metodunun içeriğini kullanabiliyor.

Object sınıfının toString metodunun içeriği ise şöyle;

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Görüldüğü üzere String nesnesi, sınıf ismi, ‘@’ karakteri ve sınıfın hash kodunun birleşiminden oluşuyor.

Şimdi kendimiz bir sınıf oluşturalım ve sınıfın String gösterimine bakalım;

public class Person {
	public String name;
	public int age;
}

Görüldüğü üzere 2 elemana sahip basit bir Person sınıfı. Hemen nesnesini yaratıp şu haliyle String gösterimine bakalım.

Person mert = new Person();
mert.name = "Mert";
mert.age = 15;
String mertStr = mert.toString();

System.out.print("Mert'in String Gösterimi: ");
System.out.println(mertStr);

// Doğrudan
// System.out.println(mert);
// şeklinde de kullanılabilir.

Kod parçasının konsol çıktısı;

Mert'in String Gösterimi: Person@190d11

Görüldüğü gibi Object sınıfının toString metodu çalıştı. Şimdi toString metodunu kendimize göre yeniden yazalım (Object sınıfının toString metodunu Person sınıfında Override etmiş oluyoruz).

public class Person {

	// ... Sınıfın diğer kısımları

	public String toString() {
		return name + "in yaşı " + age + "'tir.";
	}
}

Önceki kod parçasının yeni konsol çıktısı artık şöyle oluyor;

Mert'in String Gösterimi: Mertin yaşı 15'tir.

Tüm anlattıklarımın geçerli olmadığı kavramlar da var tabii ki. Tüm primitif tipler (int, double vs.) bu konunun dışında kalmakta. Sebebi çok basit; primitif tipler Object sınıfından türemezler. Birer sınıf değillerdir, dolayısıyla nesneleri de oluşmaz. Object sınıfından türemedikleri için toString metoduna da sahip değillerdir (aslında sınıf olmadıkları için herhangi bir metodları da yoktur :)). Sonuç olarak, primitif tiplerin String gösterimleri yukarıda bahsettiğim yollarla olmaz.

Peki primitif tipler nasıl String haline dönüşür? Hemen bir örnekle sonlandıralım;

int int2 = 3;
String int2Str = "" + int2;
double double2 = 2.5;
String double2Str = "" + double2;

System.out.print("int2: ");
System.out.println(int2);
System.out.print("double2: ");
System.out.println(double2);

ve konsol çıktısı;

int2: 3
double2: 2.5

Ve sanırım bu kadar

Bu yazıda Java’da sınıfların String gösterimlerini elimden geldiğince anlatmaya çalıştım. Umarım herkes için faydalı bir yazı olmuştur.

Bunun için birçok yöntem mevcut ancak ben sadece ikisinden bahsedeceğim.

İlki Scanner (JRE 1.5 ile geldi) sınıfını kullanarak basit bir kullanıcı girişi;

Scanner s = new Scanner(System.in);
System.out.print("Kullanıcı Adı: ");
String userName = s.nextLine();
System.out.print("Şifre: ");
String password = s.nextLine();

if (checkUserNameAndPassword(userName, password))
	System.out.println("Sisteme başarıyla giriş yaptınız.");

// Kullanıcı adı ve şifre kontrolü yapar
private static boolean checkUserNameAndPassword(String userName, String password) {
	// bilgileri kontrol et
	//
	return true;
}

Burada nextLine metodu konsoldayken klavyeden enter tuşuna basılana kadar olan tüm girdileri alır. Scanner sınıfının nextByte, nextInt gibi başka metotları da mevcut. Her zamanki gibi inceleme kısmı size ait

Diğer yöntem;

Console c = System.console();
if (c == null) {
	System.err.println("Konsol erişimi sağlanamadı.");
	System.exit(1);
}

String userName = c.readLine("Kullanıcı Adı: ");
char[] password = c.readPassword("Şifre: ");

if (checkUserNameAndPassword(userName, password)) {
	System.out.println("Sisteme başarıyla giriş yaptınız.");
}

Öncelikle bu yöntemin sadece konsoldan çalıştırılan java uygulamalarında çalışacağını söylemeliyim (örneğin, Windows’ta Komut İstemci’sinde veya Linux’ta Terminal’de). Aksi halde (örneğin, Netbeans’te çalıştırdığınızda), “Konsol erişimi sağlanamadı.” uyarısı gözükecektir.

Console (JRE 1.6 ile geldi) sınıfının güzel iki metodu readLine (Scanner sınıfındaki metot ile aynı işi yapıyor) ve readPassword (girilen verinin ekranda gözükmeden girilmesini sağlıyor). Kod parçasının diğer kısmı ilk örnekle aynı. Dikkat edin readPassword metodu karakter dizisi döndürüyor.

İpucu konusu olduğu için yine çok detaya girmemeye çalıştım. Diğer Java İpucu yazılarım için sitenin arama kısmına “Java İpucu”, Java makaleleri için “Java Makale” yazarak aratabilirsiniz. Site özellikleri kullanımına teşvik

Herkese iyi çalışmalar.

Bir yazıyı ekrana nasıl basacağımızı gösteren küçük bir kod parçası yazalım;

System.out.println("Konsola basılacak ilk yazı");
String printTxt = "Konsola basılacak ikinci yazı";
System.out.println(printTxt);
System.out.print("Bundan sonra yazılacak yazı yanına gelecek - ");
System.out.print("Bir önceki yazının yanına gelecek yazı");

1. satırda println metodu doğrudan stringi argüman alarak konsola basıyor ve alt satıra geçiriyor. İngilizce açılımını print line (satır yaz) olarak düşünebiliriz. 3. satırda println metoduna 2. satırda oluşturduğumuz string nesnesini argüman olarak veriyoruz. 1. satırla benzer sonuç doğuruyor. 4 ve 5. satırlardaki print metodunun println metodundan farkı, gelen argümanı konsola bastıktan sonra alt satıra geçmeden bir sonraki ekrana yazma işleminin aynı satırdan devam etmesi.

Kod parçasının konsol çıktısı şu şekilde;

Konsola basılacak ilk yazı
Konsola basılacak ikinci yazı
Bundan sonra yazılacak yazı yanına gelecek - Bir önceki yazının yanına gelecek yazı

print ve println metodları String parametresinin yanında, diğer tüm primitive (int, char vb.) tipleri parametre olarak alabiliyor. Ayrıca bu metodlara Java kütüphanelerinde bulunan ya da kendi oluşturduğunuz tüm sınıfları da argüman olarak verebiliyorsunuz. Nasıl mı? Java’da tüm sınıfların ata sınıfı Object sınıfıdır. Ve bu sınıf çok sihirli bir metoda sahiptir: toString. Yani, tüm sınıflarınızın bir String karşılığı var. Bu metodu isterseniz kendi sınıfınızda override ederek içeriğini siz yazabilirsiniz. Bu işlemi yapmazsanız Object sınıfı sizin için bir gösterim yapıyor. Çok da anlamlı olmayabilir sizin için tabi

Hemen örnek kod;

Object o = new Object();
System.out.println(o);

ve konsol çıktısı;

java.lang.Object@42e816

Çıktının içeriği çok da önemli değil (meraklıları için söyleyeyim; sınıfın paket ismiyle beraber ismi ve hash kodu). Ama her sınıfın bir String karşılığı var bunu bilin yeter

Uyarı!

Bu noktadan sonrası tamamen meraklı ve usta kullanıcılar içindir. Uyarmadı demeyin

Örnek kod parçalarındaki

System.out.println

satırını irdeleyelim biraz. Bu satırda aslında, System sınınıfın out alanının println metodunu çağırıyoruz. System sınıfı nesnesi oluşturulamayan ve türetilemiyen bir sınıf  (final class). out, System sınıfının static bir alanı (değişkeni) ve PrintStream tipinde. print ve println metotları ise aslında PrintStream sınıfının metodları. Kendileri de static tabii ki

Uyarı Sonu

Basit bir konuyu çok da karmaşıklaştırmamak için daha detaya girmek istemiyorum. Diğer yazılarda yeri geldikçe yeniden değinmeye çalışırım. Herkese iyi çalışmalar.

Map arayüzü, ikili verilerinizi (key ve value) tutmanızı sağlayacak kuralları belirler. HashMap sınıfı ise key verilerinizin hash değerlerini (ki bu değer  Java’da tüm sınıfların atası olan Object sınıfının hashCode metodundan gelir) Map‘in key verisi olarak tutar (HashMap‘ten başka TreeMap ve AbstractMap gibi Map türleri de mevcuttur). Örneğin, bir gruptaki kişilerin yaşlarını <isim,yaş> ikilisi şeklinde tutabilirsiniz. Bir nevi indeks değeri istediğiniz bir nesne olabilen dizi diyebiliriz.

HashMap sınıfının en büyük özelliği put ve get işlemlerini yani bir key değerine ait value değerini tutma ve istenilen zamanda okuma işlemlerini birim zamanda yapabilmesidir. Deminki örnek üzerinden gidersek, gruptaki Hakan’ın yaşı 24, Melis’in yaşı 21 ise, Hakan ve Melis’in yaşlarını birim zamanda edinebiliyoruz.

Şimdi de kod üzerinden nasıl kullanıldığına bakalım;

HashMap ages = new HashMap();

ages.put("Hakan", new Integer(24));
ages.put("Melis", new Integer(21));

Integer ageOfHakan = (Integer) ages.get("Hakan");
Integer ageOfMelis = (Integer) ages.get("Melis");

Kullanımı bu kadar basit. Kod parçasının 6. ve 7. satırlarında dikkat ederseniz veriyi alırken Integer cast işlemi yapmak zorunda kaldık. Çünkü, HashMap nesnesi her tipten value değerine sahip olabilir. get metodu da aslında bir Object nesnesi döndürüyor. Buradaki cast işleminin sakıncaları büyük ama konumuz o değil tabii ki. Başka bir yazıda da buna değinelim.

Şimdi gelelim HashTable sınıfına. Zaten söylenmesi gereken birçok şeyi HashMap ile birlikte söyledik Hemen HashTable sınıfı ve HashMap sınıfı arasındaki farkları sıralayalım (HashMap sınıf tanımında belirtildiğine göre):

• HashTable sınıfı synchronized, HashMap sınıfı unsynchronized şekilde çalışmaktadır. Benzer fark, StringBuffer ve StringBuilder sınıfları arasında da mevcuttur. Bu konu hakkındaki daha önceki yazıma bakabilirsiniz.
• HashMap sınıfı null key ve value değerlerine izin vermektedir. HashTable sınıfı null değerlere izin vermez.

Yine bir reçete vermek gerekir bu noktada değil mi?

• Multithread çalışıyorsanız ve senkronizasyon işlemi sizin için önemliyse (ve senkronizasyın işlemini elle yapmaya üşeniyorsanız) HashTable sınıfını
• Diğer hemen tüm durumlarda HashMap sınıfını kullanabilirsiniz.

String Sınıfı

Öncelikle nasıl kullanıyoruz ona bir göz atalım.

String myString = "This is a literal string";

Şöyle kullanımı da mevcut;

String myString2 = new String("This is another literal string");

ancak fazladan bir nesne yaratmış oluyoruz. Yani, bu kullanımın

String myString3 = new String(myString);

bundan bir farkı yok. Yani fazladan bir nesne oluşmuş oluyor. Java String sınıfına zaten özel olarak davranarak, ilk örnekteki gibi oluşmasını sağlıyor.

Asıl konumuza dönersek, Java dilinde String sınıfı özel bir sınıf. Sadece okunabilir formda oluşturuluyor (ki bu nesnelere immutable nesneler deniyor. İngilizce kaynak için : Immutable Objects). Yani bir kere oluşturulduktan sonra oluşturulan nesne değiştirilemiyor. Hemen bir örnekle açıklayalım:

String firstString = "first";
String secondString = "second";
String thirdString = firstString.concat(secondString);
System.out.println("1." + firstString);
System.out.println("2." + thirdString);

Kod parçasının ekran çıktısı ise;

1.first
2.firstsecond

şeklinde oluyor. concat metodu iki String nesnesinin birleştirilmesini sağlıyor (+ işlemi de aynı işi yapıyor). 3. satırda olması beklenen firstString nesnesinin değişmesi. Ancak çıktının ilk satırdan görüldüğü üzere firstString nesnesi aynen kalmış, tamamen yeni nesne oluşturulmuş. String nesnesi bir kere yaratıldıktan sonra artık değiştirilemez (immutable) hale geliyor. Görüldüğü üzere her yeni String nesnesi birleştirilmesi sırasında tamamen yeni bir String nesnesi oluşuyor. Sadece birleştirme değil, String sınıfı üzerindeki tüm düzenleme işlemlerinde yeni bir nesne oluşuyor.

Peki neden immutable nesneler var? Birincisi, işlerin basit olmasını sağlıyor. İkincisi, verimizin değiştirilemez kalmasını sağlıyor. Bunu bir örnekle açıklayacak olursak;

public class Person {

	String name;
	Date birthday;

	public Person(String name, Date birthday) {
		this.name = name;
		this.birthday = birthday;
	}

	public String getName() {
		return name;
	}

	public Date getBirthday() {
		return birthday;
	}
}

Basit bir Person sınıfı. Kişinin ismini (name) ve doğum tarihini (birthday) tutuyor.

Person ali = new Person("ali", new Date(2000, 1, 1));
String name = ali.getName();
name.concat("veli");
Date birthday = ali.getBirthday();
birthday.setYear(2023);

System.out.println("Name: " + ali.getName());
System.out.println("Birth year: " + ali.getBirthday().getYear());

Öncelikle bir Person nesnesi yaratıyoruz. Daha sonra Person sınıfının getName metoduyla ismi alıyoruz ve 3. satırda “veli” stringini ekliyoruz. Daha sonra getBirthday metoduyla doğum tarihini alıyoruz ve yılını 2023 olarak değiştiriyoruz. Kod parçasının ekran çıktısına baktığımızda;

Name: ali
Birth year: 2023

Gördüğümüz üzere immutable nesne olan name değiştirilemezken, birthday nesnesi dışardan istenildiği gibi değiştirilebildi. birthday nesnesinin de değiştirilememesini istiyorsak ekstradan bir işlem yapmamız gerekiyor. Bu konuya ayrı bir yazıda değiniriz. Burada önemli olan bunun için immutable nesnelerde ekstra bir çaba sarfetme gereksinimimizin olmaması.

Peki yoğun düzenleme işlemleri olduğunda bir sürü geçici nesne oluşmasını önlemenin yolu nedir? Yani, String sınıfının alternatifleri nelerdir? Bu noktada imdada iki sınıf yetişiyor; StringBuffer ve StringBuilder.

StringBuffer ve StringBuilder Sınıfları

Aslında bu iki sınıf sadece bir durum dışında aynı amaca hizmet ediyorlar. Hemen hemen aynı sınıflar yani (hatta sanırım tüm metotları aynı). Tek farkları, StringBuffer synchronized olarak çalışırken, StringBuilder bunun garantisini vermiyor. Bu konuya en son değinelim.

StringBuffer sınıfı String sınıfının varlığından beri var (JDK 1.0’dan beri). Amacı, immutable String sınıfının yukarıda bahsettiğimiz dezavantajlarını giderecek mutable sınıf olması. Yani, düzenleme işlemi sonucunda düzenlenen nesne de değişmiş oluyor. Hemen bir örnekle açıklayalım;

StringBuffer strBuffer = new StringBuffer("This is a StringBuffer object");
StringBuffer strBuffer2 = strBuffer.append(" and now modified.");

System.out.println("1." + strBuffer);
System.out.println("2." + strBuffer2);

ve kodun ekran çıktısı;

1.This is a StringBuffer object and now modified.
2.This is a StringBuffer object and now modified.

Görüldüğü üzere, append metodu sonucu strBuffer nesnesi de değişmiş oldu. Yoğun string işlemlerinde oldukça faydalı bir sınıf. StringBuffer nesnesini String nesnesine çevirmek de gayet kolay; toString metodu.

StringBuffer sınıfı yazılırken, multithread uygulamalar da düşünülerek synchronized (link: threadler hakkında Türkçe güzel bir makale) olarak yazılmış. Yani, multithread uygulamalarda bir thread bir StringBuffer nesnesi üzerinde değişiklik yaparken veya okurken diğer bir thread o StringBuffer nesnesine erişemiyor. StringBuffer sınıfı size synchronized olma garantisini veriyor.

Ancak, synchronized işlemi oldukça büyük bir masraf getiriyor. Eğer böyle bir duruma ihtiyacınız yoksa (genellikle single thread uygulamalarda böyle bir ihtiyaç yoktur) sizin için çok da kullanışlı bir sınıf olmayabilir. Bu durumu göz önünde bulunduran StringBuilder sınıfı JDK 1.5 ile hayatımıza girmiş durumda. Daha önce de belirttiğim gibi, StringBuffer sınıfından tek farkı synchronized olarak çalışmaması. Yani, düzenleme işlemlerinde StringBuffer sınıfından daha hızlı. Ancak, multithread uygulamalarda StringBuffer sınıfı kadar güvenli değil.

Adet yerini bulsun ve bu sınıfla ilgili de örnek yazalım;

StringBuilder strBuilder = new StringBuilder("This is a StringBuilder object");
StringBuilder strBuilder2 = strBuilder.append(" and now modified.");

System.out.println("1." + strBuilder);
System.out.println("2." + strBuilder2);

ve ekran çıktısı;

1.This is a StringBuilder object and now modified.
2.This is a StringBuilder object and now modified.

Örnek bir önceki örnekle tamamen aynı.

Son olarak konunun özeti olarak güzel bir reçete verelim :

string işlemlerinde;

• Düzenleme işlemleri çok kullanılmayacak, daha çok okuma işlemi yapılacaksa String sınıfını
• Düzenleme işlemleri sıklıkla yapılıyor ve multithread çalışılıyorsa StringBuffer sınıfını
• Tüm diğer durumlarda StringBuilder sınıfını

kullanabilirsiniz.

Oldukça basit bir reçete oldu değil mi?

İlk yöntem, Integer sınıfının parseInt metodunu kullanmak. Basit bir örnekle görelim:

public static boolean stringNumericTest1(String code) {
	try {
		Integer.parseInt(code);
	} catch (NumberFormatException numberFormatException) {
		return false;
	}
	return true;
}

Burada tek yaptığımız şey parseInt metodunu kullanarak, fırlatabileceği NumberFormatException nesnesini yakalamak. Yani, tüm işi parseInt metodu hallediyor. Eğer, metot string nesnesini int tipine çeviremez ise NumberFormatException nesnesi fırlatıyor. Güzel yanı, kullanımının sade ve basit olması. Burada dikkat edilmesi gereken nokta parseInt metodu başında “-“ karakteri olan stringleri de çevirebiliyor. Eğer bu durum sizin için uygun değilse, metottan dönen int değerinin negatif olup olmadığını kontrol edebilirsiniz.

İkinci yöntem biraz daha alt seviye bir işlem. Tüm karakter kontrolleri elle yapılıyor:

public static boolean stringNumericTest2(String code) {
	for (int i = 0; i < code.length(); i++) {
		if(!Character.isDigit(code.charAt(i)))
			return false;
	}
	return true;
}

Görüldüğü üzere, string nesnesinin tüm karakterleri sırayla dolaşılıyor ve Character sınıfının static metodu isDigit ile o karakterin nümerik olup olmadığını bakılıyor. Nümerik olmayan karakterle karşılaşıldığı anda metot false değerini döndürüyor. Tüm karakterler nümerik ise metot true değerini döndürüyor.

Üçüncü ve son yöntem ise düzenli ifadeler (regular expressions) yöntemi:

public static boolean stringNumericTest3(String code) {
	if(code.matches("[0-9]+"))
		return true;
	return false;
}

String sınıfının matches metoduna istenilen düzene sahip düzenli ifade verilerek string nesnesinin bu düzenli ifadeye uyup uymadığının kontrolü yapılıyor. Belirtilen düzenli ifade (“[0-9]+“) tam anlamıyla konuyu içeriyor : “code nesnesi 1 veya daha fazla nümerik karakterden mi oluşuyor?”. Kullanımı gayet basit bir yöntem daha. Bu yöntemin güzelliği düzenli ifadeyi değiştirerek string nesnesinin istenilen şekilde kontrolü mümkün olabiliyor. Örneğin, bilimsel notasyondaki sayılar (5e+10 gibi) bile kontrol edilebilir hale getirilebilir. Düzenli ifade bilgisi gerektiğini söylememe gerek yok herhalde

Şimdilik bu kadar. Umarım faydalı olabilecek bir konu olmuştur. Herkese iyi çalışmalar.