Thread

        S.a. Arkadaşlar,
        Bugünkü konumuz threadlar olacak. Elimizden geliğince sade bir şekilde anlatmaya gayret edeceğiz. Muhakkak hepimizin en azından bir kaç defa duyduğunu düşündüm bir kavram , fakat tam olarak nedir nasıl çalışır onu irdelemeye çalışacağız. Peki nedir thread ? Threadler kısaca çalışan iş parçacıklarıdır. Java'nın çoklu thread özelliği ile işlemci yönetimi sağlayabiliriz. Peki bu işlemci yönetiminin bize ne gibi faydaları olur derseniz işlemcinin performansından en iyi şekilde yararlanmak da diyebiliriz, fakat bunu yaparken sistemin çalışmasına etki edebileceğimizi de unutmamak gerekir. İyi uygulanmadığında başımızı ağrıtacağı da kesindir. Şimdi gelelim threadlerin kullanım şekline. Threadler 2 şekilde kullanılabilirler. Bunlardan biri kalıtım diğeri ise interface ile implement etmektir. Fakat hangisi daha uygun diye sorarsanız , bildiğimiz gibi java çoklu kalıtım izin vermediği için eğer biz class Sinif extends Thread yaparsak, kalıtım hakkımızı böyle  doldurmuş olacağız. Fakat eğer biz class Sinif implements Thread yaparsak , burada herhangi bir kısıtlama yoktu hatırlarsınız. birden fazla interface de implement edilebiliyordu. Şimdi yavaş yavaş kodlamamıza başlayıp eksik gördüğümüz yerleri tamamlamaya çalışalım

public class CoolThread extends Thread {

@Override
public void run() {
System.out.println("The job is starting!");
}

public static void main(String[] args) {
CoolThread t = new CoolThread();
Thread t2 = new Thread(new CoolThread());
                t2.run();
                //çalışan threadm canlı değildir. Canlanması için
                //start edilmeye ihtiyacı vardır
}
}

//bu 2 kod arasında çalışma mantığı olarak hiç bir fark yoktur
//fakat üstteki kod kalıtım yardımıyla çalışmaktadır
//aşağıdaki kod ise interface uygulayarak çalışmak
//yukarıda da belirttiğimiz gibi tercihimiz alttaki koddan yanadır.
//aşağıdaki koddan devam edeceğimiz için o kodu geliştirdik

class MyRunnableMoreThread implements Runnable {

@Override
public void run() {
System.out.println("run method()");
for (int i = 0; i < 10; i++) {
String name = Thread.currentThread().getName();
long id = Thread.currentThread().getId();
System.out.println("index:" + i + " " + name + " " + id);
}
}

}

public class RunnableMoreThreadTest {

public static void main(String[] args) {

MyRunnableMoreThread myRunnable = new MyRunnableMoreThread();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);

t1.setName("First");
t2.setName("Second");
t3.setName("Third");
             
                //start threadi başlatır.
                t1.start();
t2.start();
t3.start();
                //t1.run();
                //fakat run start olmadan da çalışır ama thread hala pasiftir
                //çünkü run da bir metod olduğundan referans ile çağırabiliriz
}
}

     Burada çaktığımız değişkenlik gösterir. Bunun sebebi hangi threadin hangi anda çalışacağının belli olmamasıdır. Yani thread1 çalışıyorken bir anda thread 2 onu keser , tekrar thread 1/3 thread2'yi keser ve bu şekilde devam edebilir, fakat burada önemli olan her threadin görevinin tamamlayıp sonlanacağıdır. Threadlerle ilgili bir kavramları göreceğiz. Bu sayede threadleri yönlendirebiliriz. Bu yönlendirmeleri yapabileceğimiz bir kaç kavram ve metod üzerinde duralım.

New: Threadin oluşturulduğu fakat henüz çalışmaya başlamadığı durumdur
Runnable: Threadin çalışmaya başladığı andır. Thread artık aktiftir.
Waiting: Threadin beklemede olduğu kısımdır. Aktiftir fakat çalışmaz.
Blocked: Senkronize edilmiş bir metodda çalışan thread dışındaki threadler askıya alınır.
Terminatted: Threadin faaliyetinin son bulduğu durumdur.

     Kavramlara kısaca baktık, şimdi de bazı metodlara bakıp yazımızı sonlandıralım.

Sleep: Belirtilen süreye kadar metodu bekletir. Süre bittiğinde tekrar çalışacağının garantisi yoktur. Overload metodları vardır. Parametre almayan metodu Exception fırlatır. O nedenle bu hatayı yakalamamız gerekir yoksa program hata verecektir. Statictir.

Yield: Threadlere öncelik verir. Fakat bu öncelik sıralamasının yine de bir garanti durumu yoktur. Statictir. Genelde pek kullanılmaz. Debug ve tet amaçlı kullanılabilir.

Join: Diğer 2 mtedoun aksine static değildir. Overload metodları vardır. Parametre almayan metodu exception fırlatır. Burada ise 1 metod çalışırken diğer metodlar bloklanır. Bir tür senkronize vardır.

Inner Classes-2

       S.a. Arkadaşlar,
      Bugünkü konumuz yine dahili sınıflar olacak. Birinci yazıda dahili ve interface dahili sınıfları işlemiştik. Bu yazımızda ise anonymous ve static dahili sınıfları işlemeyi düşünüyoruz. Böylece dahili sınıfları bitireceğiz. Şimdi devam kaldığımız yerden. Öncelikle anonymous dahili sınıfına başlayalım. Adından da anlayacağımız gibi belirsiz ya da adı olmayan sınıf olarak da nitelendirebiliriz. Peki bu ne demektir , isimsiz sınıf mı olur dediğini duyar gibiyim, burada isim olmasından kasıt direkt bir ad yazmak yerine , obje ile birlikte kullanılmasından kaynaklanıyor. Kod tarafına geçeceğimiz zaman yorum satırlarıyla destekleyip ne demek istediğimizi umarım daha iyi anlayacaksınız.

class Keyboard {//extends Computer, run time error
public void write() {
System.out.println("Keyboard Write");
}
        public void anotherWrite(){
               System.out.println("kEYBOARD wRITE");
        }
}
interface  Mouse { //diğer dahil sınıflardaki gibi interface
       public void move();
       public final static int sensivity=5;
       int speed=5; //yukarıdaki tanımlama ile aşağıda aynıydı hatırlarsanız
}

abstract  class Printer{ // ve soyut sınıf tanımlanabilir
        public abstract void scan();
     
}

public class Computer {

Keyboard keyboard = new Keyboard() {
@Override
public  void write() {
System.out.println("Anonymous Write");
}
                public  void bigWrite(){
                        System.out.println("ANANYMOUS WRITE");
                }
}; // noktali virgulu unutmayalim!

Keyboard keyboard2 = new Keyboard();

public static void main(String[] args) {
Computer com = new Computer();
com.keyboard.write();
com.keyboard2.write();
                //com.keyboard.bigWrite();
                com.keyboard.anotherWrite();
                com.keyboard2.anotherWrite();
             
                Mouse mouse = new Mouse() {
@Override
public void move() {
System.out.println("Anonymous Move");
}
};//noktalı virgüllere dikkat
                mouse.move();
             
                String localVariable="local";
                final String localFinal="local Final";
                Printer printer = new Printer (){
                   // static String staticVariable = "compile error"; error
                    static final String staticVariable = "run";
                    //static final void metod();
                    //metod her haliyle hata verir hatırlarsanız
                    @Override
                    public void scan(){
                            System.out.println("Anonymous Scan");
                            //System.out.println(localVariable);
                            //final olursa dışarıdaki local değişkene erişebilir
                            System.out.println(localFinal);
                         
                    }
                };//noktalı virgüller dikkat
                printer.scan();    
         }

}

      Yorum satırlarıyla elimiz geldiğince gerekli yerlerde konuyu anlatmaya çalıştık ama karışık gelmiş olabilir bazı şeyler , belki de yeterince sade anlatamamış olabiliriz. Anlamadığımız yerler olduğu zaman sormakta çekinmeyin. Birlikte öğrenmeye gayret ederiz. Şimdi de static dahili sınıflara geçelim. Static dahili sınıf aslında tam olarak dahili sınıf olarak da tanımlanmayabilir. Bu ne demek şimdi diye sorduğunuzu duyar gibiyim. Şöyle anlatalım. Bir sınıf içerisinde sıradan bir metod çağırdığımızda ne yapmamız gerekiyordu. Öncelikle bir nesne oluşturup Sinif sinif= new Sinif(); sinif.metod(); demememiz gerekliydi bildiğiniz gibi fakat bu metod static olduğunda ne yapıyorduk her hangi bir obje oluşturmadan da metodu çağırabiliyorduk. Bu static dahili sınıf da öyle , dışarıdaki sınıfa ihtiyaç olmadan değişken ve metodlara ulaşılabilir. Kod kısmına geçip örneklendirdiğimiz zaman daha iyi anlayacağınızı düşünüyoruz.

public class Outer {

static class StaticNested {
                private String instanceVariable = "I am instance variable";
private static String staticVariable = "i am static variable";
void method() {
System.out.println("StaticNested method");
                        System.out.println(instanceVariable);
                        System.out.println(staticVariable);
}

static void staticMethod() {
System.out.println("StaticNested static method");
                        //System.out.println(instanceVariable);
                        //beklenen yine oldu ve staticte static olmayan çalışmaz
                        //staticleri asil olarak düşünün, ve asiller kendi aralarına
                        //diğer tabakadakileri almıyorlar ...
                        //ama diğer tabakalardaki insanların olduğu yere
                        //asiller girebiliyor. Umarım iyi bir örnek olmuştur
                        System.out.println(staticVariable);
}
}

class InnerClass {
void method() {
System.out.println("InnerClass method");
}

                //static void staticMethod() {
                //System.out.println("compile error");
                //}
                //static olmayan sınıf içinde static metod tanımlanmaz
}

public static void main(String[] args) {

                Outer.InnerClass innerClass = new Outer().new InnerClass();
InnerClass innerClass2 = new Outer().new InnerClass();
                //yukarıdaki static olmayan dahili sınıf tanımlaması
                //aşağıdaki ise static sınıf tanımlaması
                //aradaki farka dikkat edin lütfen

StaticNested staticNested = new StaticNested();
                staticNested.method();
                //Static.method desek hata çünkü metod static değildir!!
                StaticNested.staticMethod();
                //baş harfe dikkat, küçük harf yaptığımız zaman warning veriyor
                //diyor ki obje tanımlamanıza gerek yoktur direk çağırabilirsiniz
                //bunu söylemesinin sebebi static oluşudur
}

}

    Static dahili sınıflarla birlikte hem yazımızı hem de dahili sınıfları geride bıraktık. Umarız en iyi şekilde verim alabilirsiniz. Çalışmalarınıza başarılar dileriz. Kolay gelsin

Inner Classes

        S.a. Arkadaşlar,
        Bugünkü konumuz inner classes olacak. Türkçeye dahili sınıf olarak da çevirebiliriz. Java sınıf içinde sınıf tanımlamamıza izin verir. Peki bunun bize verdiği avantajlar nelerdir dersek, Java'da bildiğimiz üzere çoklu kalıtım yoktur. Yani SubClass extends SuperClass,Super2Class gibi bir tanımlama yoktur. Bunu Java'da dahili sınıflar ve interfaceler yapar. Öncelikle kod okunurluğunu sağlar. Çünkü bir sürü sınıf yerine , her sınıfın ilgili olduğu alt sınıflarını oluşturabiliriz. Bu da bize bir sürü ayrı sınıflar yerine daha derli toplu , hiyerarşik bir yapı sağlar. Tabi bunun değerini büyük projelerde daha iyi anlayabiliriz. Ayrıca bu iç sınıflar private olarak tanımlanabilir ve kendi dış sınıfının temel elemanları hariç , diğer inner classlar erişemez, fakat bizim classlarda public ve default erişimi dışında private veya protected erişimi yoktu. Bu da bize daha iyi kapsülleme sağlar. Şimdi de bu sınıfların kullanım ve özelliklerine geçelim. Burda ise kod üzerinden ilerlemekte fayda var

public class OuterClass {

    private String gizli = "static olmayan gizli";
    private static String gizliStatic = "static ve gizli";

    public static void main(String[] args) {
OuterClass.InnerClass innerRef = new OuterClass().new InnerClass();
innerRef.innerTestMethod();
        //içinde bulunduğumuz main static ama çağırdığımız metod
        //static olmadığı için obje yardımıyla çağırmalıyız
System.out.println(innerRef.kelime);//yukarıdaki kural yine geçerli
    }

    private void outerTestMethod() {
System.out.println("Dış Test Metodu");
    }

    private static void outerStaticTestMethod() {
System.out.println("Static Dış Test Metodu");
    }

    private class InnerClass { //class olsa ya default ya public olurdu
private String kelime = "Private Tanımlama";
        //burada staticle birlikte final kullanılmazsa error verir
        private static final String staticInner = "Innerde Statiklik";
        //private static final void metod(); Hatalı
        //metod static olmaz. Çünkü static olmayan bir metod içinde
        //static bir metod tanımlamaya çalışmış oluruz
        private void innerTestMethod() {
System.out.println(gizli);
System.out.println(gizliStatic);
                     
outerTestMethod();
         //dikkat edin bir obje oluşturup çağırmıyoruz
         //çünkü zaten hem iç sınıf static değil hem metod static değil
outerStaticTestMethod();
                //staticlerde zaten direkt olarak çağırabiliyorduk
        }
    }
}

    Classlar durum şimdilik böyle , peki interfacelerde nasıl olacak peki ? İnterfaceler biraz daha farklı mesela interface , herhangi bir sınıf veya interface içerisinde tanımlasa dahi private veya protected değeri alamaz. Nedeni de hatırlayacağımız üzere interfacelerin public abstract özelliği taşıyor olmasındandır. Başka bir konu ise override konusu. Bildiğimiz gibi interfaceler içerisinde gövdesiz metod  ve sabit değişken tanımlayabiliyorduk. Peki metodları nerede override etmemiz gerekir diye soracak olursak , eğer içerideki interfaceyi kullanırsak sadece inner interfaceleri override tanımlamamız yeterlidir. Aynı şey dışarıdaki interfaceler için de geçerlidir. Kısa bir örnek yaparsak belki daha iyi anlamış oluruz.

interface OuterNestedInterface {

public abstract void outerMethod();

public interface PublicNestedInterface {
public abstract void innerMethod();
}
}

//implement ederken önce dış sonra iç sınıf yazılmasına dikkat
public class OuterNestedTest implements OuterNestedInterface.PublicNestedInterface {
 
@Override
public void innerMethod() {
//sadece içerideki metod override edilmiş !!
}

}

class Outer2 implements OuterNestedInterface {
     
@Override
public void outerMethod() {
//sadece dışarıdaki metod override edilmiş
}

}

//birden fazla extends kullanılmaz(çoklu kalıtım yoktur), fakat implementler edilebilir
class Outer3 implements OuterNestedInterface, OuterNestedInterface.PublicNestedInterface {

@Override
public void outerMethod() {
            //hem dış metod
}

@Override
public void innerMethod() {
            //hem iç metod override edilmeli
        }
}

Generics-2

      S.a. Arkadaşlar,
      Bugünkü konumuz genericsler olacak. Daha önce özet maheyetinde bir yazı yazmıştım ama şimdi daha farklı bir özellikleri ile ele alacağız. Birinci yazıya buradan erişebilirsiniz. Bu konuyla ilgili temel bilgileri orada bulabilirsiniz. Burada biraz daha ayrıntılı olarak ele almaya çalışacağız. Belki konuya paldır küldür girmiş gibi olacağız ama yaptığımız örnekler jeneriklerin özellikleri ile ilgili neler yapılıp neler yapılmayacağı ile ilgili gibi düşünün. Şöyle söylememek gerekirse bildiğimiz gibi dizilerde IS-A kavramını kullanmamıza izin veriyordu, fakat jeneriklerde nasıl oluyor diye bir soru aklımıza gelirse ? Bir bakalım hemen nasıl olduğuna ..

class Living {
 
}

class Animal extends Living{
 
}

class Dog extends Animal {

}

public class ArrayTestMethod {

public static void main(String[] args) {
Animal[] animalArray = new Animal[5];
Dog[] dogArray = new Dog[5];
Animal[] animalDogArray = new Dog[5];
                //burada görüldüğü gibi Dog IS-A Animal
                //olduğundan hata olmayacaktır
             
arrayRules(animalArray);
arrayRules(dogArray);
arrayRules(animalDogArray);
                /******************************/
                List<Animal> animalList = new ArrayList<Animal>();
List<Dog> dogList = new ArrayList<Dog>();
                List<Living> livinglist= new ArrayList<>();

addAnimal(animalList);
addAnimal(dogList);//dikkat
                //eğer = extends wildcardsı kullanılmasa
                //Dog subclass bile olsa error verecektir
                //ama dizilerde böyle bir durum yok
             
                //addAnimal(livinglist);//dikkat ? extends wildcardı
                //yerine ? super olsa bu kod çalışacaktır fakat bu sefer de
                //dogList çalışmayacaktır. Çünkü Super üst sınıflara izin verirken
                //extends ise altı sınıflara izin verir.
             
             
}

public static void arrayRules(Animal[] animal) {
System.out.println("test");
}
     
        public static void addAnimal(List<? extends Animal> animalList) {
            //burada ise sadece null ekleyebiliriz
            animalList.add(null);
            //? extends kaldırdığımız zaman
            //addAnimal(new Dog()); gibi bir tanımla yapılabilir
}
}

Set && Map

      S.a. Arkadaşlar,
      Bugünkü konumuzda yine koleksiyonlardan devam edeceğiz , fakat bu sefer farklı bir yazıyla devam edeceğiz. Bu sefer de set ve map sınıflarını inceleyeceğiz. Öncelikle Set sınıfımızla başlayalım. Set sınıfımızda hashSet,linkedHashSet ve treeSet lerden bahsedeceğiz. Genel olarak arrayListlerle aynı olsa da bazı yönleriyle farklıdır gösterirler. Mesela aynı 2 eleman eklenemez. Derleyici hata vermez, fakat hafızasına bir adetini alır. treeSette order ve sorted iken diğerleri bu iki özelliği aynı anda taşımaz. Daha önce de zaman zaman açıkladık ordered ve sorted konusunu yine kısaca söylemek gerekirse bir tür sıralamadır int ve String arasında. Bu nedenle TreeSetlerde farklı tipler kullanılamaz. Çünkü String ile int karşılaştıramaz, ama diğer ikisinde ise jenerik ile kısıtlama yapılmadığı sürece kısıtlama yapılabilir. Örnekle söyleyecek olursak

public class TreeSetTest {
    public static void main(String[] args) {
LinkedHashSet<Number> linkedHashSet = new LinkedHashSet <Number>();
           
linkedHashSet.add(2);//normalde aynı elemanı 2 defa bulundurmaz
linkedHashSet.add(2L);//fakat bu değişkenlerin her biri farklı tiptedir
linkedHashSet.add((short)2);
        for(Number aaa: linkedHashSet) System.out.println(" " + aaa);
             
Set treeSet = new TreeSet();
        Set<Number> ts1= new TreeSet<Number>() ;
//treeSet.add((short)10);//türü short olduğundan yine hata
treeSet.add(20);
//treeSet.add("ClassCastException");
        for(Object aa: treeSet) System.out.println(" " + aa);
}
}

      Kısaca Setler böyle , ArrayListle benzerlikleri çok fazla, o yüzden önemli gördüğümüz bir kaç noktayı belirtmiş olduk. Şimdi de maplara geçiyoruz. Map kısmını da 4 başlık altında inceleyeceğiz. Bu üç başlığa geçmeden önce maplerin genel özelliklerinden biraz bahsedelim. 2 kısımdan oluşurlar. 1.si key 2.si value kısmıdır. 1.kısım primer key gibidir. Yani değerleri farklı olmak zorundadır, fakat value değeri birden farklı değerler alabilirler. Eğer key kısmında birden fazla aynı değer varsa en altta olan değer geçerli sayılacaktır. Bunun sebebi override etmesidir. Şimdi de bahsettiğimiz 4 kısmına geçelim. Onlardan da kısaca bahsedip daha sonra da kodla açıklamaya çalışalım.

HashMap: Unordered ve Unsorted. null değerler alabilir. Farklı değişkenler alabilir
Hashtable: null değerler alamaz.
LinkedHashMap:. Null değer alabilir.
TreeMap: Sıralıdır ve ordered. Bu yüzden aynı tip değişken alır

    Burada HashMap ve Hashtable HashSet ile benzerlik özellikler gösterse de LinkedHashMap burada biraz daha farklı , bu yüzden biz de ağırlığımızı LinkedHashMap üzerine vermeyi düşünüyoruz.

    public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();

treeMap.put(1, "one");
treeMap.put(2, "two");
treeMap.put(30, "thirty");
treeMap.put(40, "forty");
treeMap.put(50, "fifty");
treeMap.put(70, "seventy");
treeMap.put(100, "hundred");

// ceilingEntry(key) 41den büyük en küçük sayı döndürür
        //40 yazsak 40 key/value kısmını seçecekti
Entry<Integer, String> ceilingEntry = treeMap.ceilingEntry(40);
Integer ceilingEntryKey = ceilingEntry.getKey();
String ceilingEntryValue = ceilingEntry.getValue();
System.out.println("ceilingEntryKey: " + ceilingEntryKey);
System.out.println("ceilingEntryValue: " + ceilingEntryValue);

// higherEntry(key)  40den küçük en büyük key/value döndürür
        //40 olsa dahi 40ı almaz, dikkat !!
Entry<Integer, String> higherEntry = treeMap.higherEntry(40);
Integer higherEntryKey = higherEntry.getKey();
String higherEntryValue = higherEntry.getValue();
System.out.println("higherEntryKey: " + higherEntryKey);
System.out.println("higherEntryKey: " + higherEntryValue);

// floorEntry(key)  kendisinden küçük en büyük sayıyı döndürür
        //aynı değer varsa onu seçer
Entry<Integer, String> floorEntry = treeMap.floorEntry(30);
Integer floorEntryKey = floorEntry.getKey();
String floorEntryValue = floorEntry.getValue();
System.out.println("floorEntryKey: " + floorEntryKey);
System.out.println("floorEntryValue: " + floorEntryValue);

        // floorEntry(key)  kendisinden küçük en büyük sayıyı döndürür
        //aynı değer varsa onu seçmez
Entry<Integer, String> lowerEntry = treeMap.lowerEntry(30);
Integer lowerEntryKey = lowerEntry.getKey();
String lowerEntryValue = lowerEntry.getValue();
System.out.println("lowerEntryKey: " + lowerEntryKey);
System.out.println("lowerEntryValue: " + lowerEntryValue);

        //ilk değeri döndürür
        Entry<Integer, String> firstEntry = treeMap.firstEntry();
Integer firstKey = treeMap.firstKey();
        System.out.println("ilk Deger:" + firstKey);
             
        //son değeri döndürrü
Entry<Integer, String> lastEntry = treeMap.lastEntry();
Integer lastKey = treeMap.lastKey();
        System.out.println("Son Deger:" + lastKey);
             
        //ilk değeri döndürür ve siler
        Entry<Integer, String> pollFirstEntry = treeMap.pollFirstEntry();
        //son değeri döndürür ve siler
        Entry<Integer, String> pollLastEntry = treeMap.pollLastEntry();
             
        //Mapin son hali. ilk ve son elemanları silinmiş!!
        for(Object key: treeMap.keySet()) System.out.println(key);
       }

    Burada TreeMapin bazı metodlarına baktık , unutmayın bu metodları TreeSet ile de kullanabiliriz. Örnekleri çoğaltıp sizler de kafanıza takılan yerleri cevaplandırabilirsiniz. İyi çalışmalar Kolay gelsin

Comparable & Comparator ile Sıralama

       S.a. Arkadaşlar,
       Bugünkü konumuz ArrayListelerde sıralama olacak, fakat bu sıralamalarımız basit manada String veya int sıralamak değil de , bir önceki yazımızda bahsettiğimiz objeler arasında sıralama olacaktır. Ne demek istiyoruz peki , elimizde bir tip değişken var. Örneğin int[] dizi={1,4,2,3}; gibi bir dizi olsun elimizde bunu nasıl sıralıyorduk Arrays.sort(dizi) yazıyorduk ve sıralama yapıyorduk. ArrayListlerde de buna benzer bir olay var. Orda Collection.sort() diye sıralama yapıyoruz, fakat bazen karşımıza bir sınıf geldiğini ve bunun birden fazla değişkeni olduğunu düşünelim hangisine göre sıralama yapacağı ise muallakta kalacağı için işte tam bu noktada comporable ve comparator devreye girer. Şimdi kodumuz üzerinden gidelim. Umarım bu sayede daha iyi pekişecektir söylemeye çalıştıklarımız.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Car implements Comparable <Car>{
        //<Car> enerjik ile sınırlama getiriyor
        //Sınırlama koymak istemezsek comporTo metodunda 
        //değişiklik yapmak zorundayız.Car yerine Object tanımlanmalı
public Car(String marka, Integer fiyat) {
super();
this.marka = marka;
this.fiyat = fiyat;
}

String marka;
Integer fiyat;

@Override
public int compareTo(Car car) {
return fiyat.compareTo(car.fiyat);
                //eğer ters sıralama yapmak istersek
                //car.fiyat.compareTo(fiyat);
                //markaya göre sıralama yapmak içinse
                //return marka.compareTo(car.marka);
}
               //burada compareTo ile neye göre sıralama
               //yapmak istediğimizi override etmezsek hata alırız

@Override
public String toString() {
return "Car [ marka=" + marka + ", fiyat=" + fiyat + "]";
}

}

public class ComparableTest {

public static void main(String[] args) {
Car ford = new Car("ford", 100);
Car fiat = new Car( "fiat", 50);
Car subaru = new Car("subaru", 5000);
Car bmw = new Car("bmw", 1000);


List <Car> carList = new ArrayList <Car>();
carList.add(ford);
carList.add(fiat);
carList.add(subaru);
carList.add(bmw);
                carList.add(new Car("mercedes",250));//böyle de yapılabilir


for (Car c : carList) {
System.out.println(c);
}
System.out.println();

Collections.sort(carList);

System.out.println("Comparable Sorting");
for (Car c : carList) {
System.out.println(c);
}

}
}
       
    Yukarıda Comparable yapısını anlatmaya çalıştık Gerekli yerlerde yorum satırlarıyla kodlarımızı destekledik. Umarız anlamanıza yardımcı olmuştur. Şimdi de Comparator yapısına geçelim. Bunun için yine kodumuzu yazıp içerisini yorum satırlarıyla desteklemeye çalışacağız.


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Car {

public Car() {
            //hatırlarsanız eğer herhangi bir constructor
            //tanımlamazsak otomatik oluşuyordu .
}

public Car(String marka, Integer fiyat) {
            super();
            this.marka = marka;
            this.fiyat = fiyat;
}

String marka;
Integer fiyat;

@Override
public String toString() {
            return "Car ["+ " marka=" + marka + ", fiyat=" + fiyat + "]";
}
}

public class ComparatorTest implements Comparator<Car> {
// Doğal sıralama için  Comparable , bundan farklı
        //bir sıralama içinse comparator kullanılır
public static void main(String[] args) {
            Car ford = new Car("ford", 100);
            Car fiat = new Car( "fiat", 50);
            Car subaru = new Car("subaru", 5000);
            Car bmw = new Car("bmw", 1000);

            List<Car> carList = new ArrayList <Car>();
            carList.add(ford);
            carList.add(fiat);
            carList.add(subaru);
            carList.add(bmw);

            for (Car c : carList) {
System.out.println(c);
            }
            System.out.println();

            ComparatorTest comparatorTest = new ComparatorTest();
            // overloaded sort metodunu kullanabiliriz.
            // burada 1.arguman siralamak istedigimiz List
            // 2.arguman ise Comparator arabirimini uygulayan sinifimiz olacaktir.
            Collections.sort(carList, comparatorTest);
            //Arrays.sort metodu da gerekli kodlamalarla kullanılabilir

            System.out.println("Comparator Sorting");
            for (Car c : carList) {
System.out.println(c);
            }
}

// Comparator -> compare metodunu override etmemiz gerekir
// Comparable -> compareTo metoduydu.
@Override
public int compare(Car car1, Car car2) {
            return car2.fiyat.compareTo(car1.fiyat);
           //tersten sıralamak için car1 ile car2 yer değiştirilmeli
}

}

ArrayList

       S.a. Arkadaşlar,
       Bugünkü konumuz ArrayList olacak. Dizileri hepimiz biliyoruzdur. Dizilerde ne yapıyorduk eleman tutuyorduk,siliyorduk vs fakat burada bir diziye tek bir tip değişken atayabiliyorduk. Mesela int[] a= new int[size]; diyorduk ve sadece intenger tanımlayabiliyorduk. Fakat arraylistlerde farklı tipleri tanımlama olanağı sağlar fakat siz bunu istemezseniz jenerikler ile de kısıtlama yapabiliyorsunuz. Jenerik konusunu ileri ki konularda anlatacağız inşallah, fakat bir nevi tip kısıtlaması dersek şuan için bize yeterli olacağını düşünüyorum. Ayrıca arraylistler dinamik yapılardır. Eleman ekledikçe genişleyen sildikçe küçülen yapılardır. Dizilerde sabit bir boyut veriyorduk bildiğiniz gibi ve bundan fazla eleman ekleme şansımız olmuyordu. Daha az eleman eklediğimizde ise boşuna bellekte yer tutmuş oluyoruz. ArrayListlerin böyle bir avantajı da var. Son olarak eleman silme gibi işlemler veya araya eleman ekleme gibi konularında diziler için ekstra kod yazmanız gerekirken ArrayListler bunu kendisi hallediyor ve size bir zorluk çıkarmıyor. Sayılar ve String için sıralama yapabiliyor, fakat farklı objeler için sıralama yapamıyor. Mesela bir Car sınıfımız var , onun için farklı yöntemler var onları da ileride nasip olursa anlatırız. Şimdilik teknik olarak söyleyeceklerimiz bunlar. Kodlar içerisinde eksik gördüğümüz yerleri yine anlatmaya çalışacağız. Şimdi yavaştan kod kısmına geçelim.

public static void main(String[] args) {
ArrayList myArrayList = new ArrayList();
// ArrayList'e elemani add metodu ile ekleyebiliriz.
myArrayList.add(10);
myArrayList.add((short)20);
myArrayList.add("test");
        myArrayList.add(true);
        myArrayList.add(new Test());//paketismi+sıfınismi+@id
myArrayList.set(2, "new set text");//set ile indexteki elemani override
myArrayList.add(1, '#');//overload ile yeni eleman ekleyebiliriz
       //set ile farkı elemanı üzerine yazılmaz, elemanı aşağı kaydırır.
for (Object obje: myArrayList) {
System.out.println(obje);
}
             
        boolean isEmpty = myArrayList.isEmpty();//ArrayList Boş mu,boşsa true
int size = myArrayList.size(); // kaç elemanlı
        System.out.println(isEmpty + " Eleman Sayısı: " + size);
             
        boolean b= myArrayList.contains(20);//burada int olduğu için false
        boolean b2= myArrayList.contains((short)20); //short olduğundan true
        boolean b3= myArrayList.contains("10"); //yukarıda int burada String!
        System.out.println(b+ " " + b2+ " " + b3);
             
       int indexOf = myArrayList.indexOf(10); //indexini atar
       int indexOf2 = myArrayList.indexOf(20); //int olduğundan -1 döndürür
       int indexOf3 = myArrayList.indexOf((short)20);
       System.out.println(indexOf + " " + indexOf2 + " " + indexOf3);
             
      myArrayList.remove(0); //index siler
      System.out.println("0.eleman Silindikten Sonra:" + myArrayList.size());
      myArrayList.clear(); //tüm arraylisti siler
     System.out.println("Dizi tamamen silinince" + myArrayList.size());
     //şimdi diziyi tekrar yazdıralım,görüldüğü üzere birşey yazmaz
     for (Object obje: myArrayList) {
     System.out.println(obje);
      }
}

      Peki biz array ile arrayList arasında herhangi bir dönüşüm yapabilir miyiz diye bir soru sorarsak onun da cevabı evet olacak. Her iki dönüşüme de izin veriyor. Bunun için birden fazla yol olabilir fakat biz kendiliğinden gelen toArray ve asListleri kullanacağız. Bu iki yöntem arasında farklar vardır. Bunları burada söylemektense kod içerisinde uygularken yorum satırlarıyla desteklemeyi tercih edelim.

public static void main(String[] args) {
     String[] namesArray = { "names1", "names2", "names3", "names4" };
      List namesList = Arrays.asList(namesArray);
      // Arrays -> List dönüşümü yapıyoruz

for (String str : namesArray) {
System.out.print(str + " ");
}
             
// List'teki elemani guncellersek otomatik olarak
                //dizi arraydeki eleman da guncellenecektir.
                //fakat toArray ile güncellenme olmayacaktır
namesList.set(0, "set new names1");
             
                System.out.println("");
for (String str : namesArray) {
System.out.print(str + " ");
}
// namesList.add("java.lang.UnsupportedOperationException");
                //bu şekilde eleman eklemeyiz fakat to Array bu böyle değildir
             
}

NOT: adList ile toArray görev olarak aynı olsa dahi özellik olarak birbirlerinin tersi gibidirler. Kodun içinde gerekli açıklamaları yapmaya özen gösterdik. Yazımızı burada son veriyor , iyi çalışmalar diliyoruz.

Enum

        S.a. Arkadaşlar,
        Bugünkü yazımız enumlar olacak , belki daha önce anlatmam gereken veya yer yer bahsettiğim bir konu olduğu halde , tekrardan hem bir başlık altında toplamak hem de atladığım, gözden kaçırdığım yer olursa onları da almak adına enumlar adında bir yazı yazalım dedik. Peki nedir enumlar ? Sabitlerin değerleri temsil ederler. Fakat bunu yaparken daha derli toplu, anlaşılır bir halde yaparlar. Bu nedenle bu yapıyı kullanırız. Java'ya da 1.5 sürümüyle eklenmiştir, daha öncesinde dediğimiz gibi sabitler (constant) kullanılırdı. Kısaca bir örnek yapacak olursak;
public class TrafikLambasi {
  public static final int GREEN = 1;
  public static final int YELLOW = 0;
  public static final int RED = -1;
}

yerine kısaca

 enum TrafficLight {
  GREEN(1),YELLOW(0), RED(-1);
   TrafficLight(int value) { //int yerine farklı değişkenler tanımlanabilir. 
                                       //GREEN(değişken türüne değer atanır)
    }
yazabiliriz. Şuan durum o kadar da karışık değil çünkü sadece 3 değişkenimiz var. Mesela bu aylar gibi 12 değişken veya farklı yapıda belki yüzlerce değişken kullanacağımız bir proje olsa, ne demek istediğimiz daha iyi anlaşılırdı. Böylece enumla bu karışıklığın önüne geçiyoruz. Şimdi de aşağıda yazdığımız kodda enumlarla ilgili temel şeyler yazmaya çalıştık. Kafanıza takılan şeyleri siz de kodun  üzerinde farklı işlemler yaparak aklınızdaki soruları gidermeye çalışın , böylece daha iyi oturtacağınıza inanıyoruz.

enum Outer { //enum dışarıda tanımladığında sadece default ve public alabilir
     //implements alabilir interfacelerden fakat extends ile kalıtım yapamaz
SHORT, NORMAL, TALL;
         Outer(){
          //class ve abstract sınıflar gibi constructor tanımlanailir
          // ama hatırlarsanız interfacelerde constuctor tanımlayamıyorduk  
        }
}; //noktalı virgül zorunlu değil

class JavaCoffee {
    protected enum Inner{ //içeride tanımlanırsa private ve protected de alabilir
        SHORT1,NORMAL1,TALL1;
            static enum InnerEnumClass{
                //iç içe enum tanımlanailir, static de olabilir
            }
        Inner() {
          //constructora public gelemez. Nedeni enum protected olmasıdır.
          //ya aynısı ya da daha gizlisi olmalıdır !! bunu da tekrar hatırlattık  
        }
         
}; // noktalı virgül zorunlu değil
Outer size;
        Inner size1;
 
    static void metod(){
       //enum InMetod{} , metodlar içinde tanımlanamazlar
     
    }

}

public class JavaCoffeeTest {
public static void main(String[] args) {
JavaCoffee coffee = new JavaCoffee();
             
                //Outer outer = new Outer(); yeni obje oluşturulmaz
             
                //enum sınıf dışında tanımlanırken
coffee.size = Outer.NORMAL;
System.out.println(coffee.size);
                //senum sınıf içinde tanımlanırken
                coffee.size1 = JavaCoffee.Inner.TALL1;
                System.out.println(coffee.size1);
             
}
}

Tokenizing & Formating

      Bugünkü konumuzda tokenizing ve formating konusunu işleyeceğiz. Bir önceki konuda regex konusu ile birbirinden yakındır fakat mantık regex bulma işlemi yaparken burada büyük parçalardan küçük parçalara veya başka bir ifadeyle istenilen formata çevirme yöntemi vardır. Şimdi örneğimize geçersek ne demek istediğimizi daha iyi anlarız

public class StringSplitTest {
    public static void main(String[] args) {
        String content = "name1,name2,name3,name4";

        String[] names = content.split(",");
        for (String s : names) {
            System.out.println(s);
        }
        //burada virgüle göre parçalama yapıyoruz

        content = "name1,name2:name3:name4.name5@name6";
        System.out.println("virgul - iki nokta-nokta- @");
        names = content.split(",|:|\\.|@");
        // onceki yazida isledigimiz gibi ,birden fazla bölme parametresi de kullanabiliriz
        // benzer sekilde noktayi kullanmak icin kacis karakteriyle kullanılmalıdır. \\.
        for (String s : names) {
            System.out.println(s);
            }
         }
      }

     Gördüğünüz gibi buradaki bir bütün olan metni kelimeler ayırdık. Bu ayırma işlemi boşluklara göre de
olabilirdi. Her boşlukta kelimeyi hafızaya alıp yazdırabilirdik veya satır satır alma işlemi de olaiblirdi.
Satır sonuna gelindiğinde satırı hafızaya da alabilirdi. Bu tip örnekler çoğaltılabilir tabii ki de ..

      Aşağıdaki kodda ise tokenizin işlemi ile searching işleminin arasındaki farkı daha iyi anlaycağınızı umuyorum.

 public static void main(String[] args) { Pattern p = Pattern.compile("\\s");//boşluk String content = "merhaba java!"; System.out.println("Searching Test"); Matcher m = p.matcher(content); while (m.find()) { System.out.print(m.start() + " "); // Searching islemi ilgili regexi bulma islemidir. } System.out.println(); String[] tokens = content.split("\\s"); System.out.println("Tokenizing Test"); for (String token : tokens) { System.out.println(token); // Split/tokenizing ise regexe göre parçalama işlemidir } } }

Şimdi de formating konusunda bakalım. Formating C'den yabancı olmadığımız bir konu. Aynı şey java için de 
geçerlidir. b boolean , c char, d integer, f floating point, s string kullanılır. Birazdan örneklerde göreceğimiz 
şekilde bu tanımlamalar böyle yapılır. Şimdi örnek kodumuza geçelim.

public static void main(String[] args) {

System.out.printf("%d", 10);
System.out.println();
  System.out.format("%d", 10);//format metonu da kullanabiliriz
  System.out.println();

//System.out.printf("%f",10);
// java.util.IllegalFormatConversionException hatasi verecektir.
// %f kayan noktali sayilar/kusuratli sayilar icindir.


System.out.printf("%2$d %1$d  %3$f", 123, 456, 10.4);
// index$ ifadesi ile arguman olarak verilen ddeğerleri düzenleyebiliriz.
System.out.println();//456 123 10.4

System.out.printf("%05d", 123);
// 0 , metoda sayimizin hanesini belirtir
                // sayımız 5 haneden büyükse her hangi bir değişiklik yapmaz
System.out.println();

System.out.printf("%+d %+d", 123, -123);
// Varsayilan olarak pozitif sayilarda + isareti eklenmez. + karakterini
// ekleyip formatlayabiliriz.
System.out.println();

System.out.printf("%(d %(d", 123, -123);
// ( parantez isareti negatif sayilari parantez icerisine alir.
// negatif sayiyiyi pozitif olarak formatlar , mutlak degerini alir.
System.out.println();

System.out.printf(">%d< \n", 123);
System.out.printf(">%7d< \n", 123);
System.out.printf(">%-7d< \n", 123);
// - karakteri formatlamayi sola dayali yapar.
}

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/