Java kodlaması yaparken hemen hepimiz string işlemleri için String sınıfını kullanırız. Çünkü kullanımı basittir ve ekstradan bilgi ihtiyacı gerektirmez. Peki ya performans? Bu kullanım kolaylığı bize performans olarak nasıl yansıyor? Gelin şimdi String sınıfının avantaj ve dezavantajlarından bahsederek, yerine hangi durumlarda hangi sınıfları kullanabileceğimize göz atalım.
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? 🙂
