String , StringBuffer&Builder

Bugünkü konumuzda Stringleri anlatmaya çalışacağız. Stringler nedir ? Kullanımları nasıldır ? Ne gibi özelliklere sahiptir ? gibi soruların cevabını arayacağız. Öncelikle immutable /değişmezlik nedir ona bakalım. Stringlerde obje değişmez , onun yerine yeni bir obje oluştururu. Örn String x="a"; olsun. x üzerinde herhangi bir değişiklik yaptığımız zaman x.metod(); burada x değişmez , yeni bir nesne daha oluşur. İşte bu özelliğe immutable diyoruz. Belki kodla daha iyi anlayabilir.

public static void main(String[] args) {

String s1 = "spring ";
// 1)"spring" degerine sahip bir String objesi olusur.

String s2 = s1 + "summer "; //spring summer
// 2)"summer" objesi olusur
// 3)"spring summer" objesi olusur
// s2 referansına "spring summer" objesine referansta bulunur

s1.concat("fall "); //spring full , fakat s1 hala spring !!
//4) "fall" degerine sahip String objesi olusur.
//5) "spring fall" degerine sahip String objesi olusur.
               // s1 in referans gosterdigi obje degismez !

s2.concat(s1); //spring summer spring (s1 hala spring demiştik)
                                //aynı nedenle s2 de hala spring summer
//6) "spring summer spring" objesi olusur.

s1 += "winter "; //şimdi artık spring winter oldu
//7) "winter" degerine sahip obje olusur.
//8)"spring winter" degerine sahip obje olusur.

System.out.println(s1 + " " + s2);
                //spring winter spring summer 

}
Şimdi de sık kullandığımız bazı metodlara bakalım.

length(): bildiğimiz üzere uzuluğu hesaplayan fonksiyondur. int döndürür.
public static void main(String[] args) {
String name = "xyz";
int len = name.length();
System.out.println("karakter sayisi:" + len);
}

isEmpty():stringin boyutu 0 ise true , değilse false değer döndürür.
public static void main(String[] args) {
String str = "";//str="xyz" olsa false değer döndürecekti
                                     //null olsa hata fırlatır
boolean isEmptyString = str.isEmpty();
System.out.println(isEmptyString);
}

charAt():Stringdeki karekteri almamızı sağlıyor
public static void main(String[] args) {
String name = "xyz";
char c = name.charAt(2);
System.out.println(c); //y
                // tanımlanmayan değişken olduğunda exception fırlatır
}

getChars(int baslangic, int end, char dst[], int hedefBaslangic):Stringdeki belirli bir yer almayı sağlar. parametrelerde isimlerini belirttik şimdi bir örnekle daha iyi pekiştirelim. Bu arada dizilerin ilk indexinin sıfır olduğunu unutmayalım.

public static void main(String args[]) {

String str = new String("abcdefgh");
char[] charArray = new char[4];
str.getChars(2, 6, charArray,0);
System.out.println(charArray);//cdef

}

compareTo&compareToIgnoreCase: Karşılaştırma yapar. Aradaki fark kadar int değer döndürür. CompareTo küçük büyük harf hassasiyeti varken , comporeToIgnoreCase ise bu yoktur. Örneklerde ne demek istediğimizi daha iyi anlayacaksınız

public static void main(String[] args) {
 
    System.out.println("a".compareTo("d"));
    System.out.println("b".compareTo("d"));
    System.out.println("e".compareTo("a"));
    System.out.println("ABa".compareTo("ABc"));
    //AB aynı olduğu için a ile c karşılaştırır
    System.out.println("a".compareToIgnoreCase("A"));
     //küçük büyük harf hassasiyeti yoktur.//0
    System.out.println("a".compareTo("A"));
 
    }

Şimdi de StringBuffer ve StringBuilder yapılarını inceleyelim. Nedir peki bu iki yapı. Yukarıda belirttiğimiz gibi String imuutable'di yani değişmez. Bir obje değiştiğinde bir asıl obje bir de referans obje oluşuyordu. Bu memory yoruyor. Bu nedenle bu yapılar ortaya çıkmıştır. Ne dediğimizi kod üzerinde daha iyi anlayacağınızı umuyorum

public static void main(String[] args) {
 
    StringBuffer sb = new StringBuffer("abc");
    sb.append("def");
    System.out.println("sb = " + sb);  //abcdef
    //eğer yapımız sb değil de String olsaydı çıktımız abc olacaktı
    }

Şimdi de her iki tarafta kullanılan bazı metodlara bakalım.
append():ekleme işini yapar. Aşağıdaki örnekte

public static void main(String[] args) {
StringBuffer sb = new StringBuffer("yaşamak");
sb.append(" güzel ");
sb.append(2015);
                //sb="bu atanma tipi yanlış.DİKKAT!!"

System.out.println(sb);
}
delete():belirtilen indexler arası silme işlemi yapar.
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("0123456789");
sb.delete(4, 6);
// index 0 dan baslayacaktir!
// [start-end)
System.out.println(sb);
}

insert(); append'den farklı olarak istenilen yere ekleme yapar.
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("0123456789");
sb.insert(4, "----"); // 4.indexten sonra ekleme yapar
System.out.println(sb);

}

toString(): String Buffer ve String Builder objelerini objeye çevirir.
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("test string");
                String deneme=sb.toString();
                deneme+="boyle ekleyebiliriz artk";
                System.out.println(deneme);
                 
}

Kaynakça
http://www.injavawetrust.com/pure-java-53-string-01/
http://www.injavawetrust.com/pure-java-54-string-methods/
http://www.injavawetrust.com/pure-java-55-stringbuffer-and-stringbuilder/

Wrapper Classes Metod ve Özellikleri

        Bugünkü konumuz yine Wrapper Classes olacak. Bir önceki yazımızda nedir ne değildir sorusunun cevabını aramıştık. Bugün ise biraz daha işin derinlerine girmeyi düşünüyoruz. Önceki yazımıza erişmek isterseniz buraya tıklayınız. Peki nedir bu metodlar:

valueOf()   String ---> Wrapper    Örn : String-> Long
xxxValue()  Wrapper ---> primitive  Örn ; Long->long
parseXXX()  String ---> primitive  Örn; String-> long

Şimdi burada ne demek istediğimizi kodlarla açıklamaya çalışacağız. O zaman konunun daha iyi oturacağını temenni ederiz. Sizi şimdi kodlarla baş başa bırakalım.

public class Wripper3lu {
    public static void main(String[] args) {
        //ValueOf metodu Kullanımı
        //aynı işlemleri diğerleri için de yapabiliriz
        Float f1 = Float.valueOf("10.5"); // Sting->Wrapper
Float f2 = Float.valueOf("10.5f");
Float f3 = Float.valueOf(10);    //float->Float| primative->Wrapper
Float f4 = Float.valueOf("10");
System.out.println(f1 + " " + f2 + " " + f3 + " " + f4 );
     
        //xxxValue metodu Kullanımı
        Integer i1 = new Integer(100);
        short s = i1.byteValue();
short s2 = i1.shortValue();
// short s3 = i1.intValue(); // int>short olduğundan error
// short s4= i1.longValue(); //long>short olduğundan error
System.out.println(s + " " + s2);
     
      long lo1 = i1.byteValue();
long lo2 = i1.shortValue();
long lo3 = i1.intValue();
long lo4 = i1.longValue();
        //dikkat edin long'ta hiç hata olmuyor.Çünkü veri kaybı söz konusu değil
System.out.println(lo1 + " " + lo2 + " " + lo3 + " " + lo4);
     
        //ParseXXX Metodu Kullanımı
        byte b1 = Byte.parseByte("10");
//byte b2 = Short.parseShort("10"); 
        //bunlarla ilgili bol bol örnek yapmak faydanıza olacaktır
        //Çünkü biz tek tek yazsak da sizin kodlamanızın önemi apayrıdır
     
float f11 = Byte.parseByte("10");
float f21 = Short.parseShort("10");
float f31 = Integer.parseInt("10");
float f41 = Long.parseLong("10");
//float f51 = Double.parseDouble("10"); double>float error
        System.out.println(f1 + " " + f2 + " " + f3 + " " + f4);  
    }
}

       Yukarıda metodları elimizden geldiğince yorum satırlarıyla anlatmaya çalıştık , fakat dediğimiz gibi örneklerle konuyu daha iyi pekiştirebilirsiniz diye düşünüyoruz. Şimdi de bazı özelliklere bakalım. Boxing, autoboxing, unboxing , autounboxing gibi bazı özelliklere de kısaaca göz atıp yazımızı tamamlayalım.

        Integer boxing = Integer.valueOf(10);
        Integer autoboxing =10;
        int unboxing = boxing.intValue();
        int autounboxing=10;

Değişken isimlerini barındırdığı özellik ile yazdık. Belki de bildiğimiz şeylerdir, fakat isim olarak nedir ne değildir bilmiyorduk, bununla birlikte yazımızı burada son veriyoruz. İyi çalışmalar

Kaynak
http://www.injavawetrust.com/pure-java-35-wrapper-03/
http://www.injavawetrust.com/pure-java-34-wrapper-classes-02/

Metoda ilkel Veri ve Nesne Gönderimi

                Bugün metoda veri tipi gönderme üzerinde duracağız. Ayrıntı olarak metodları anlatmayacağız. Anlatacağımız konu ilkel verileri ile nesnelerin gönderimi arasındaki farktan bahsedeceğiz. Bildiğimiz gibi Java’da 8 tane ilkel tip vardı (Long, int, double, byte, short, float, char, boolean). Ve bunun dışında kalan her şey nesneydi. Şimdi bu iki tür arasında nasıl bir fark olduğunu birlikte inceleyelim. Bu konuda benim de daha önceden kafam karışıyordu. Fakat aşağıdaki kodlar sayesinde bu konuyu daha iyi anladım. Umarım okuyanlara da faydalı olur diye anlatmaya çalışacağım. Öncelikle ilkel veri gönderimi göndereceğiz. Burada bir sorun yok beklenen oluyor. Sözü fazla uzatmadan koda geçelim.

public class OrnekTemelTip{

    public static void main(String[] args){

        int sayi = 5; ;//int değil de diğer ilkel değişkenler de olabilir

        System.out.println("Metottan Once = " + sayi);//5

        degerArttir(sayi);

        System.out.println("Metottan Sonra = " + sayi); // 5

    }

   

    public static void degerArttir(int deger){

        deger += 1;

        System.out.println("Metod İçinde = " + deger); //6

    }

}

        Önceden bildiğimiz gibi burada 5 değerini gönderiyoruz. Metoddan değer 6 oluyor fakat main içindeki değişkenin değeri aynı kalıyor. Fakat bu nesnede nasıl oluyor bir de ona bakalım

public class OrnekReferansTip{

    public static void main(String[] args){

        TamsayiSinifi d = new TamsayiSinifi();

        d.sayi = 5;

        System.out.println("Metottan Once = " + d.sayi);//5

        degerArttir(d);

        System.out.println("Metottan Sonra = " + d.sayi);//6

    }

   

    public static void degerArttir(TamsayiSinifi d){

        d.sayi += 1;

        System.out.println("Metod içinde = " + d.sayi);//6

    }

}

class TamsayiSinifi{ 

    public int sayi;

}

Burada ilkel veri göndermeden farklı olarak main içindeki değişken de artık 6 değerini alıyor. Bunun nedeni objenin kendisini değil de referansını göndermemizden kaynaklanıyor. Ama temel veride sayının bizzat kendisi gönderiliyordu. Umarım aradaki farkı anlamanıza yardımcı olabilmişizdir.

Kaynak:

Kodlar Aybars Uğur'dan alınıp bir kısmı değiştirilmiştir

Static Değişken ve Metodlar

S.a. Arkadaşlar,
Bugünkü yazımızda static değişken ve metorları incelemeye çalışacağız. Nedir peki bu static olma konusu, bir sınıfta çağırılıp her yerde erişilebilen değişkenlerdir. Tek bir kopyası vardır ve her yerde o kopya üzerinde işlem yapılır. Örneğin elimizde farklı sınıflardan erişmek istediğimiz bir değişkenimiz olsun. Bunu nasıl kullanabiliriz. İşte tam da bu sorunun cevabıdır aslında static kavramı. Şimdi yazdığımız bir kod üzerinde bunu incelersek umuyorum ki taşlar yerine daha iyi oturacaktır.

public class SayacArtir {

    

static int count = 0;

        int sayac=0;

SayacArtir() {

count++;

                sayac++;

}

void method1() {

System.out.println("metod1 içinde count Değeri:"+count); 

          System.out.println("metod1 içinde sayac Değeri:"+sayac);          

}

     
static void method2(){

         System.out.println("Metod2 içinde count Değeri:"+count); // OK

        //System.out.println(sayac); // ERROR

        //static olan metoddan static olmayan değer çağrılmaz 

 }

public static void main(String[] args) {

        new SayacArtir();

        new SayacArtir();

new SayacArtir();

                

//method1(); //static olan metod içinden static olmayan metod çağrılmaz

SayacArtir sayacArtir= new SayacArtir();

        sayacArtir.method1();//ancak böyle tanımlayıp çağırırız

        method2(); //fakat static metodu nesne oluşturmadan direkt çağırabiliriz

        System.out.println("Main içinde Count Değeri:" + count); 

        //System.err.println(""+sayac); static olmadığından error verir

        System.out.println("Main içinde Sayac Değeri:"+sayacArtir.sayac);

}

}

ÇIKTI:

metod1 içinde count Değeri:4

metod1 içinde sayac Değeri:1

Metod2 içinde count Değeri:4

Main içinde Count Değeri:4

Main içinde Sayac Değeri:1

       Burada önemli bir konu daha vardı o da static metodların override edilmemesiydi.Bunu yukarıda da belirmiştik ama şimdi bunu kod ile incelersek daha iyi ifade etmiş oluruz kendimizi ve böylece konuyu noktalamış oluyoruz. Not: Aşağıdaki kod scjp kitabından alıntıdır.

class Animal {
  static void doStuff() {
    System.out.print("a ");
  }
}
class Dog extends Animal {
  static void doStuff() {
    System.out.print("d ");  //burada override olmamıştır.
    //eğer metod static olmasaydı çıktığımız a d olacaktı
  }
  public static void main(String [] args) {
    Animal [] a = {new Animal(), new Dog()};
    for(int x = 0; x < a.length; x++)
      a[x].doStuff();          
  }
}

ÇIKTI
a a