Regex-Searching&Finding

      Bugünkü yazımızda birbirinden farklı fakat birbiriyle yakın konuları işleyeceğiz. Regex konusu ile başlayalım hemen , aşağıdaki örnekte yorum satırlarında açıklamalar var. Kafanızı karıştırmadan umarım sadece ve anlaşılır olabilir

public static void main(String[] args) {
Pattern p = Pattern.compile("a");//birden fazla harf de olabilir
// ilgili icerikte/content "www.java.com.tr" "a" harfini arar
             
Matcher m = p.matcher("www.java.com.tr");

while (m.find()) { //bu işlemler 1 kez çalışır!!
System.out.print(m.start() + " ");
}
             
System.out.println();
             
Pattern p3 = Pattern.compile("j|w|t");//"[jwt]" yapıların aynıdır
// arama yaparken or yapısını | ile kullanabiliriz
Matcher m3 = p3.matcher("www.java.com.tr");

while (m3.find()) {
System.out.print(m3.start() + " ");
}
System.out.println();
             

Pattern p5 = Pattern.compile("[jwt][ar]");
// ilk 3 karekterden herhanginden biri sonrası 
                //sonraki a veya r'den biri gelmelidir
Matcher m5 = p5.matcher("www.java.com.tr");

while (m5.find()) {
System.out.print(m5.start() + " ");
}

System.out.println();
Pattern p6 = Pattern.compile("[a-z]");
// a-z arasında tüm karekterleri alır
                //dikkat edin noktaları ve 'R' almaz
                //aynı şey rakamlar için de geçerlidir
Matcher m6 = p6.matcher("www.java.com.tR");

while (m6.find()) {
System.out.print(m6.start() + " ");
}
System.out.println();
             
Pattern p8 = Pattern.compile("[^ajw]");
// caret ajw dışındakileri bul demektir. Değilini almak gibi
Matcher m8 = p8.matcher("www.java.com.tr");

while (m8.find()) {
System.out.print(m8.start() + " ");
}

}

    Yukarıda bazı ifadeler görüyoruz. Örneğin ; [a-z] bu ne demekti , a ile z arasındaki tüm karekteri al , veya [0-9] tüm rakamları al demektir. Peki bunun kısa bir yolu yok mu ? Onun için de matekarekter diye ifade ettiğimiz bir kavram var. Şimdi onu verelim . Ondan sonra da bir örnekle konuyu daha iyi inceleyelim

public static void main(String[] args) {

Pattern p = Pattern.compile("\\d");
// \d -> [0-9] anlamina gelmektedir.
                // \\D -> [0-9] dışındaki karekterleri içerir
Matcher m = p.matcher("java1 reg2ex!");

while (m.find()) {
System.out.print(m.start() + " ");
}


Pattern p3 = Pattern.compile("\\s");
// \s -> bosluk karakterini bulur.
                // \SS -> boşluk dışındakileri bulur
Matcher m3 = p3.matcher("java1 reg2ex!");

System.out.println();
while (m3.find()) {
System.out.print(m3.start() + " ");
}

Pattern p5 = Pattern.compile("\\w");
// \w -> harf veya rakam
                // \\W-> harf ve rakam dışındakiler
Matcher m5 = p5.matcher("java1 reg2ex!");

System.out.println();
while (m5.find()) {
System.out.print(m5.start() + " ");
}

Pattern p7 = Pattern.compile("a.c");
// . karekteri buraya her hangi bir karekter gelebilir demektir

Matcher m7 = p7.matcher("ac abc a c a  d");
// ac yi almaz cunku arada bir karakter yok.
// abc , a c yi alır . ac almaz arada birşey yoktur
System.out.println();
while (m7.find()) {
System.out.print(m7.start() + " ");
}

}

    Şimdi de bu ifadelerin sayıları ile ilgili bir örnek verelim. Mesela ab'den sonra kaç tane karekter gelebilir veya ab'den sonra her hangi birşey gelsin mi gelmesin gibi şeyler de talep edilebilmektir. Bunun için + ? * gibi ifadeler yer almaktadır. Şimdi örnekteki kodda ne demek istediğimizi umarız daha iyi anlatabiliriz.

public static void main(String[] args) {

Pattern p = Pattern.compile("\\w");
Matcher m = p.matcher("1 a12 234b");

while (m.find()) {
      System.out.println("start : " + m.start() + " end :" +
                                                  m.end() + " content:" + m.group());
     // start metodu match/eslesen regex icin baslangic indexi verir.
      // end metodu match/eslesen regex icin baslangic indexi verir.
// group metodu match/eslesen regexi verir.
}

Pattern p2 = Pattern.compile("\\d+");
                // + karakteri 1 veya daha fazlası
                // * karekteri 0 veya daha fazlası
                // ? 0 veya 1 tane anlamına gelir
                // \\d{n} n tane rakam içermesine bakar 
Matcher m2 = p2.matcher("1 a12 234b");
System.out.println("one or more");
while (m2.find()) {
System.out.println("start : " + m2.start() + " end :" +
                                                    m2.end() + " content:" + m2.group());
}

//burada karışık bir örnek var. Siz de böyle çalışmalar yapabilirsiniz
Pattern p5 = Pattern.compile("0[xX][0-9a-fA-F]");
// 0 ile baslasin 2.karakter x veya X olsun sonrasinda rakam(0-9) 
                //ya da a-f ya da A-F arasinda harf olsun.
Matcher m5 = p5.matcher("12 0x 0x12 0Xf 0xg");
System.out.println("more regex");
while (m5.find()) {
System.out.println("start : " + m5.start() + " end :"  +
                                                    m5.end() + " content:" + m5.group());
}

}

Tarih&Saat İşlemleri

                Bugünkü konumuz tarihler. Tarihlerle ilgili farklı paket,sınıf ve metodlar inceleyeceğiz. Hangisinin nerede kullanılması veya hangi koşullarda sizin işinizi görecek olanı seçmek ise size kalmış. Sözü fazla uzatmadan date sınıfını inceleyelim. Date sınıfında eskiyen bir çok metod vardır , fakat bununla birlikte hala kullanılan önemli metodlar vardır. Biz örneklerimizi incelemeye başlayalım.

     public static void main(String[] args) {

                 Date date = new Date();

                 long time = date.getTime();

                 System.out.println(time);

                //1970'dan şuana milli saniye

                              

                   long now = System.currentTimeMillis();

                   System.out.println(now);//aynı işlev

                  Date date2 = new Date(now);

                  System.out.println(date2);

                //Ayrıntılı Tarih

                

                int karsilastir= date.compareTo(date2);

                System.out.println(karsilastir);

                //burada ise 2 tarihi karsilastirdik

                //aynı olduğundan 0 döner

                //negatif olsa soldaki daha eski manasındaydı

                }

        Şimdi de Calendar sınıfını inceleyelim.  Date sınıfındaki metodlar java tarafından eski , tabiri caizse modası geçmiş olarak tabir edilir ve kullanılması tavsiye edilmez. Derleyici tarafından da üzeri çizikli olur. Onun yerine Calendar sınıfını kullanılması daha yerinde olur. Fakat Calendar sınıfı soyut bir sınıf olduğu için Date sınıfındaki Date date= new Date(); diye obje oluşturamayız. Buraya dikkat etmemizde fayda var.

                

             public static void main(String[] args) {

                  Calendar calendar = Calendar.getInstance();

                //Calender calender = new Calendar(); soyut sınıfı olduğundan hata

                  System.out.println(calendar instanceof GregorianCalendar);

                //GregorianCalender extends Calendar manasındadır.

                  System.out.println(calendar);

                 Date date = calendar.getTime();//kalıtım olduğundan doğru ifade

                Date date2 = new Date();

                 System.out.println(date + "\n" + date2);

                  // her iki ifadenin de çıktısı aynıdır

               

                int year= calendar.get(Calendar.YEAR);//yılı verir

                int month= calendar.get(Calendar.MONTH); //ayı verir

                int day= calendar.get(Calendar.DAY_OF_MONTH);//ayın haftası

                int hour= calendar.get(Calendar.HOUR); //12 saatlik dilimine göre 

               

                System.out.println("Yil:" + year + " Ay:" + month +

                   " Gun:" + day + " Saat:" + hour);

                //bu örnekler tabi ki çoğaltılabilir. ctrl+space siz de görebilirsiniz

                }

         Şimdi de text.DateFormat ve text.SimpleDataFormat sınıflarını işleyeceğiz. Date format sınıfı da soyut bir sınıftır. Simple sınıfı da ondan kalıtıldığı için doğal olarak o da soyut olur ve new objesini kullanamayız, onun yerine getInsance veya overload moteodlar kullanılır. Aşağıdaki örnekte göreceksiniz bu iki sınıfla küçük örnekler yaptık. Burada Simple sınıfı bana çok kullanışlı geldi, fakat sizlerin kullanımına göre tabi bu değişebilir

      Son olarak da tarih ve saatlerin formatlanması konusunda bakalım. Gerekli yorumlar kod kısmında yer almaktadır.

 public static void main(String[] args) {

NumberFormat numberFormat = NumberFormat.getInstance();

                

int maxFractionDigits = numberFormat.getMaximumFractionDigits();

// varsayilan olarak 3 tur

int minFractionDigits = numberFormat.getMinimumFractionDigits();

// varsayilan olarak 0 dir

System.out.println("minimum fraction digits :" + minFractionDigits);

System.out.println("maximum fraction digits :" + maxFractionDigits);

double salary = 123.456789;

System.out.println(salary);

System.out.println(numberFormat.format(salary));

numberFormat.setMaximumFractionDigits(5);

// virgulden sonraki kullanilan rakam sayisi maximum 5 olsun.

System.out.println(numberFormat.format(salary));

double salary2 = 123;

System.out.println(salary2); // double sayi icin tek 0 koyacaktir.

numberFormat.setMinimumFractionDigits(2);

// virgulden sonraki kullanilan rakam sayisi minimum 2 olsun.

// eger yoksa 00 olarak ekleyecektir.

System.out.println(numberFormat.format(salary2));

numberFormat.setMaximumIntegerDigits(5);

// virgulden once maximum 5 karakter olsun

numberFormat.setMinimumIntegerDigits(3);

// virgulden once minimum 3 karakter olsun.

System.out.println(numberFormat.format(123456789));

System.out.println(numberFormat.format(89));

                

        }

        Şimdi de format ve parse metodlarına bakıp yazımı bitirelim

public static void main(String[] args) {

NumberFormat numberFormat = NumberFormat.getInstance();

// NumberFormat sinifindadki parse Number->String

// NumberFormat sinifindaki format metodu String->Number

// parse metodu ParseException firlatabilir.

try {

System.out.println(numberFormat.parse("123.456789"));

System.out.println(numberFormat.parse("123,456789"));

                        System.out.println(numberFormat.parse("1a23456789"));

                        //System.out.println(numberFormat.parse("a123456789"));

                        System.out.println(numberFormat.format(123.23));

} catch (ParseException e) {

e.printStackTrace();

}

}

}

Kaynak

http://www.injavawetrust.com/pure-java-61-dates-numbers-currency-date-calendar/

http://www.injavawetrust.com/pure-java-62-dates-numbers-currency-dateformat-simpledateformat/

http://www.injavawetrust.com/pure-java-64-dates-numbers-currency-numberformat-currency-decimalformat/

Serialization/Serileştirme

                Bugünkü konumuz serizilation yani serileştirme olacak. Peki nedir serileştirme diye kısaca söyleyecek olursak bir andaki durumu kaydetme , daha sonra da kayıtlı olan durumu çekme işlemine diyoruz. Serileştirme özellikle network ve persistance işlemlerinde sıkça kullanılır. Serileştirmeyi kullanabilmemiz için implements Serializable . yazmamız gerek. Buradan anlayacağımıza göre serileştirme interface/ara birimdir. Şimdi konuyu daha iyi anlayabilmek için kod üzerinden devam edelim.

class Dog implements Serializable {

                String name = "Karabas";

}

public class SerializeDog {

public static void main(String[] args)

 throws IOException, ClassNotFoundException {

    Dog dog = new Dog();//dog objesi oluşturuyoruz

    FileOutputStream fos = new FileOutputStream("dog.serial");

    //dog.serial diye kaydediyoruz,farklı bir şey de olabilir

    ObjectOutputStream oos = new ObjectOutputStream(fos);

    oos.writeObject(dog);//oluşturduğumuz objeyi kaydediyoruz

    oos.flush();//bufferden bağımsız kaydeder

    oos.close();//açık olanı kapatmak zorundayız

                              

    FileInputStream fis = new FileInputStream("dog.serial");

    //şimdi okuma işlemini yapıyoruz

    ObjectInputStream ois = new ObjectInputStream(fis);                         

    Dog deserializedDog = (Dog)ois.readObject();

    //veri kaybı olmaması için cast yapıyoruz

    System.out.println(deserializedDog.name);//ekrana yaz

    ois.close();//açılan dosyayı kapat

                              

                }

}

Peki tüm değişkenleri serileştirmek zorunda mıyız diye bir soru akla gelebilir. Tam da bu nokta transient keywordu karşımıza çıkar. Serileştirmek istemediğimiz değişkenin başına yazıyoruz. Mesela yukarıdaki örneğimizde eğer transient String … yapsaydık çıktımız null olacaktı. Şimdi de son bir örnek verip , o örnekler üzerinde farklı işlemler yaparak nasıl farklı çıktıları aldığımızı incelemeye çalışacağız. Bu açıdan konunun daha iyi pekişeceğini inanıyorum. Çünkü neden bu böyle olmuş , böyle olursa ne olur gibi sorularının cevabını da bulmuş olacağımıza inanıyorum. Şimdi kodumuzu yazalım

class Animal { //serileştirme işlemi yapılsa çıktı değişir

int height = 30;

        //String name="akbas";*

}

public class Dog extends Animal implements Serializable {

String name;//* bu kodu silmezsek yukarıdaki name değişkeni pasif kalır

public Dog(int height, String name) {

this.height = height;// bu satırları silerken 

this.name = name; // çıktımız 30 akbas olur !!

}

public static void main(String[] args) throws IOException, ClassNotFoundException {

    FileOutputStream fos = new FileOutputStream("dog.ser");

    ObjectOutputStream oos = new ObjectOutputStream(fos);

    Dog dog = new Dog(50, "karabas");

    System.out.println(dog.height + " " + dog.name);

    oos.writeObject(dog);

    oos.close();

    FileInputStream fis = new FileInputStream("dog.ser");

    ObjectInputStream ois = new ObjectInputStream(fis);

    Dog deserializedDog = (Dog) ois.readObject();

    System.out.println(deserializedDog.height + " " + deserializedDog.name);

    ois.close();

}

}

  Çıktı:

50 karabas

30 karabas

    Burada çıktımız yukarıdaki gibi oldu. Fakat niye böyle oldusunu irdeleyelim isterseniz. Çünkü deserializetion işlemi sırasında yapılandırıcılar ve değişkenlere değer atanamıyor. Bu nedenle çıktımız böyle oldu. Dikkat edin Animal sınıfımıza serileştirme işlemi yapılmamış , eğer ona da serileştirme işlemi yaparsak bu sefer çıktımız değişecektir. Farklı satırlara bazı bilgiler ekledik. Sizler de aklınıza takılan soruları kodu değiştirerek daha iyi anlayabilirsiniz. Kolay gelsin

Kaynak

http://www.injavawetrust.com/pure-java-60-file-and-io-05-serialization/

Dosyalarda Giriş Çıkış İşlemleri

      Bugünkü konumuzda I/O işlemlerini anlatmaya çalışacağız. Bunun için farklı sınıflar metodlar kullanılmaktadır. Biz de bunlardan bir kaç tanesini ele almaya düşünüyoruz. Şimdi yavaştan başlayalım. Öncelikle dosya işlemini ele alalım. Burada dosya içeriği oluşturulmaz sadece dosya yoksa oluşturulur varsa herhangi bir işlem yapılmaz. Şimdi örneklersek daha iyi anlayacağımızı düşünüyorum

public class FileTest {

public static void main(String[] args) throws IOException {
File file = new File("test.txt");// burada sadece obje oluşturulur
System.out.println(file.exists()); // dosya var mi ?
System.out.println(file.createNewFile()); // doya yoksa oluşturulur
System.out.println(file.exists()); // tekrar kontrol et !

}
}

   Bu kodu ilk çalıştırdığımızda kodumuz
false
true
true
   2.defa çalıştırığımızda ise
true
false
true

döndürecektir. Bunun nedeni ise ilk çalıştırdığımızda test diye bir dosya yoktur. file.createNewFile ile oluşturulur. Daha sonra tekrar kontrol ettiğimzide artık böyle bir dosya mevcut elimizde ve true dönüyor. 2.sefer çalıştırıdığımızda ise bu sefer dosya olduğu için true döndürür ve yeni dosya oluşturulmadığı için creanteNewFile false değer döndürür.

      Şimdi de File ile ilgili daha farklı özelliklere göz atalım. Şimdi de dizin oluşturma ve oluşturduğumuz dizi içerisine dosya oluşturma işlemine göz atalım.

public static void main(String[] args) throws IOException {
File mydir = new File("mydirectory");
mydir.mkdir();  // dizin olusturma islemi atlandi.
        //eğer yukarıdaki dizi oluşturmadan txt oluşturmaya kalkışırsak hata verir
File file = new File(mydir, "test.txt");//oluşan dizi içine txt oluşur
file.createNewFile();

}

Şimdi de silme işlemine göz atalım. Ama unutmamız gereken bir şey var ki o da  dizin altında herhangi bir klasör varsa dosya silme işlemini gerçekleştirmez. Onun için öncelikle dosyaları daha sonra boş olan klasörleri silebiliriz. Buraya dikkat etmemiz gerekir. Şimdi de yukarıdaki koda ek olarak aşağıdaki kodu veriyoruz.

// dizin bos olmadiginda silme islemi yapilamaz.
// false deger donecektir
System.out.println(mydir.delete());

// dosya silinir , true deger donecektir
System.out.println(file.delete());

// dizin icerisindeki dosyayi sildikten sonra tekrar deneyelim.
System.out.println(mydir.delete()); //ve artık silme işlemi tamamlanır

Bunun gibi daha farklı işlemler bulunmaktadır. İsim değiştirme listeleme gibi işlemler bulunur. Bunlara da göz atılabilir. Biz şimdilik bunlara girmiyoruz. Son olarak da dosyaya yazma ve okuma ile yazıyı bitiriyoruz

public static void main(String[] args) throws IOException {

    File file = new File("file.txt");

    FileWriter fw = new FileWriter(file);
    fw.write("java");
    fw.write(" 6");
    // write metodu ile String veya char array yazabiliriz. 
    // int alan   yapilandiricisi ilgili sayinin unicode degeridir.
    fw.flush(); // Verinin bufferdan bağımsız diske hemen yazılmasını sağlar
    fw.close(); // IO islemlerinde , DB baglanma islemlerinde close metodu
    // cagrilmalidir. Bu baglantinin kapatilmasi anlamina gelmektedir.
    // Acik baglanti birakmamak icin close metodunu cagirmayi unutmayalim !

    char[] input = new char[50];
    int size = 0;
    FileReader fr = new FileReader(file); // FileReader objesi olusturduk
    size = fr.read(input); // dosya icerigini oku
    System.out.println("size:" + size); // kac byte okundu ?

    for (char c : input) {
    System.out.print(c);
         }
    fr.close();
    }
}

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/

Try Catch

     Bugün de try-catch kullanımını ve bazı ince noktalarını ele almaya çalışacağız. Öncelikle try catch nedir onu inceleyelim. Beklenmeyen anlarda ortaya çıkan hataları yakalayan ve hataların yerine neyin çalıştırılmasını sağlar. Şimdi yavaş yavaş kodlamaya başlayalım. Hem kodlarken söylediklerimizi daha iyi ifade edebiliriz.

public static void main(String[] args) {

try {
System.out.println("try 1");
throw new NullPointerException();//hata fırlatıyoruz
} catch (NullPointerException e) {
System.out.println("catch 1"); //hata olduğundan girer
} finally {
System.out.println("finally 1"); //her koşulda girer
}

try {
System.out.println("try 2");
} catch (NullPointerException e) {
System.out.println("catch 2"); // hata olmadığından çalışmaz
} finally {
System.out.println("finally 2"); // catchden bağımsız çalışır
}


try {
System.out.println("try 3");
System.out.println(10 / 0); //
} catch (NullPointerException e) {
                        System.out.println("catch 3");
                    //nullPointerException değil aritmetikException olmalıydı
                        //bu yüzden bu catch yakalanmaz
} finally {
System.out.println("finally 3"); // her şartta çalışır
}
}
Gerekli yorumları kod üzerinden vermeye çalıştık. Şimdi de dicked exception diye nitelendirilen tabire göz atalım. Dicked exception nedir, kısaca ona bir göz atalım daha sonra kod kısmında ne istediğimi daha iyi anlatmış olacağımızı umuyorum. Alt alta sıralanan metodlar olsun ve bu metotların belirli bir hiyerarşisi olsun. Bu hiyerarşi içerisinde yukarıdan aşağı hata fırlatmaya başlasın ve bu hata bir alta devreder. Eğer hatayı yakalayacak bir try catch yoksa bir diğerine devreder, en sonunda bu işlem tüm programı etkiler. Fakat aradaki metodlardan birini bunu engellerse hata tüm programı etkilemeyecektir. Ne demek istediğimi şimdi kod ile anlamaya çalışalım.

public class DuckedException {
public static void main(String[] args) {
doStuff();
System.out.println("Hata yakalandi, uygulama calismaya devam eder.");
               //try cath hiç kullanılmasaydı doğal olarak bu satır da gelmeyecekti
}

static void doStuff() {
try{ // eğer burada da try catch kullanılmamış olsaydık
                      //hatayı main içerisinde yakalamamız lazımdı
                      //main içerisinde yakalanmadığında programımız çökecekti
doMoreStuff();
}catch(Exception e) {
              //e.printStackTrace(); ile de hatanın türünü saptayabiliriz
}
}

static void doMoreStuff()   {
int x = 5 / 0; //burada herhangi bir try catch kullanılmadığından
                 //hata doStuff metoduna intikal eder.
  // ArithmeticException hatasi firlatilacaktir.
}
}

Biz bu yazıda genelde try catch ile hata yakalamayı gördük, fakat throws keywordi ile de hata fırlatabiliriz. try-catch ile hata fırlatmaya handle , throws ile hata ayıklamaya da declare denir. Bununla ilgili de bir örnek verecek olursak;

void throwMeAgain() throws IOException {
try {
throw new IOException();
} catch (IOException e) {
throw e;
}
}

                                                      Resim-1[1] Exceptionlar

Kaynakça
[1]https://gelecegiyazanlar.turkcell.com.tr/konu/android/egitim/android-101/trycatchfinally-yapisi
http://www.injavawetrust.com/pure-java-47-handling-exception-01/
http://www.injavawetrust.com/pure-java-48-handling-exception-02/

Döngüler

      Bugünkü anlatacağımız konu döngüler. Hepimizin bildiği bir konu  fakat biz burada gözden kaçan veya ince ayarları üzerinde durmaya çalışacağız daha çok. Bu nedenle fazla uzatmadan koda geçelim.

public static void main(String[] args) {
int x = 1;
if (x == 3) { //bu değeri sağlamaz , sağlasa diğer else/else if gitmez
}
else if (x < 4) { //bu koşul sağlar bu nedenle else/else if gitmez
System.out.println("<4");
}
else if (x < 2) { //koşul doğru ilk else if girdiği için çıktı vermez
System.out.println("<2");
}
   if (x < 5) { //if i her koşulda kontrol eder, doğru olduğu için girer
System.out.println("<5");
}
 else {      //hiç bir koşul sağlanmazsa gelir
                        System.out.println("x tüm bunlar dışında");
                }
  /*else if(x<6) {      elseden sonra else if gelmez,fakat if gelebilir
                        System.out.println("<6");
                }*/
}

 Kodu yorum satırlarıyla elimizden geldiğince açıklamaya çalıştık. Şimdi de switch case yapısına bakalım

public static void main(String[] args) {
int x = 1;
final int a=3;
                int b=2;
                long y=2;

switch (x) {
                        //x byte,int,short,byte ve Wrapperları olabilir !!
                        //x yerine y yazarsak hata verir. Long double float olmaz
case 1:
System.out.println("1 secenek aktif");
//break olmadığı için break görünceye akdar devam eder.
                 
case 2: //2 yerine b yazamayız, final tanımlanması olmalı
System.out.println("2 secenek aktif");
break;//break olmasa seçenek 3 de aktif olacaktı
                 
                default: // 1,2,3 dışındaki seçeneklerde aktif olur
                         //default en sonda olmak zorunda değildir
System.out.println(" default aktif");
                 
case a:
System.out.println("3 secenek aktif");
break;

}
}
Kodu yine yorum satırlarıyla açıklamaya çalıştık. Bir kaç ince noktaya da değinmeye çalıştık. Şimdi do while ile while döngülerine kısaca bakalım.

public static void main(String[] args) {
int x = 5;
do{
                    System.out.println("dongu icerisi");
                    //while döngüsü olsa buraya girmezdi
                    //fakat do while hatalı bile olsa bir kere çalışır
                    }
                while (x > 5) ;
System.out.println("dongu disi");

}
Şimdi ise eski ve yeni for döngüsüne bakalım ..

int a[] = { 1, 2, 3, 4 };
for (int x = 0; x < a.length; x++) {
    System.out.println(a[x]);
}

//yeni diye tabir ettiğim for döngüsü
for(int n:a){
    System.out.println(n);
}

2 for arasındaki farka bakalım biraz isterseniz. 1.döngü sayısını kesin olarak bildiğimiz yerlerde kullanabiliriz, 2.döngüyü ise daha çok array,koleksiyon işlemlerinde kullanıyoruz. İkisi de birbrinin işi yaptığı halde geliştirilmiş for bazen daha rahat olabilir fakat eski forun kendine göre önemli avantajları elbet vardır. Şimdi eski forun kullanımı ile ilgili bir kaç for döngüsü yazalım..

for(;;); bu kullanım doğrudur , for sonsuza kadar devam eder.
for(int i=0;i<3;System.out.print("aa"),i++);//çıktısı aa aa aa olur
int y,x;for(x=1,y=5; x>5; x++,y-- );
// 2seçenek hariç 1 ve 3 virgül ile farklı değişkenler kullanılabilir
for(int x=1,y=5; x>5,y<2; x++,y-- ); 
//burada hem int x hem y<2'den dolayı hata verir.

Son olarak geliştirilmiş for ile ilgili bir örnek verelim
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class TestAnimal {
public static void main(String[] args) {
Animal[] animalArray = { new Dog(), new Cat(), new Cat() };
Dog[] dogArray = { new Dog(), new Dog(), new Dog() };

for (Animal d : animalArray);
// for (Dog d2 : animalArray) ; ISA'ya uygun değil. ERROR
                for (Animal d1 : dogArray);
for (Dog d3 : dogArray) ;
}
}
Şimdi de break ve continue keywordlerine bakıp konuyu bitirelim

public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
                            continue;//çift sayıları atlıyor
                            //continue olmasa çıktı 123456 olacaktı
}

if (i == 7) {
break;//7yi bulduğu an döngü sonlanıyor
                                //continue olsa break olmasa 13579 olacaktı
}
System.out.println("i:" + i);
}
}
// 1 3 5

Kaynakça
http://www.injavawetrust.com/pure-java-43-flow-control-01/
http://www.injavawetrust.com/pure-java-44-flow-control-02/
http://www.injavawetrust.com/pure-java-45-loops/
http://www.injavawetrust.com/pure-java-46-break-continue/