Collections – Sorted Map Interface

Hi all! Today i’m going to tell about Sorted Map Interface. We talked about Map Interface before this article. This interface extends Map interface. For example class that implements this interface is TreeMap.
Sorted Map doesn’t allow null keys and null values and it stores elements by sorting with keys.

Let’s take a look Sorted Map methods in shortly

subMap(K fromKey, K toKey) : It returns part of Map with keys range.
headMap(K toKey) : It returns part of Map whose keys are strictly less than toKey
tailMap(K fromKey) : It returns part of Map whose keys are greater than or equal fromKey
firstKey() : It returns fırst key currently in this Map.
lasKey() : It returns last key currently in this Map.
comparator() : It returns the Comparator used to order the keys in this Map.

Let’s check the example code.

import java.util.*;

public class Main {

    public static void main(String... args) {
        SortedMap<Integer, String> ageNameMap = new TreeMap<>();
        ageNameMap.put(26, "Ufuk");
        ageNameMap.put(24, "Halis");
        ageNameMap.put(28, "Alice");

        write(ageNameMap);
        System.out.println("---------------------------------------");
        System.out.println(ageNameMap.subMap(24,26));
        System.out.println(ageNameMap.headMap(27));
        System.out.println(ageNameMap.tailMap(25));
        System.out.println(ageNameMap.firstKey());
        System.out.println(ageNameMap.lastKey());
    }

    private static void write(Map map) {
        Set<Map.Entry> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println("Key : " + entry.getKey());
            System.out.println("Value : " + entry.getValue());
        }
    }
}
Advertisements

Collections – Map Interface

Hi everyone! Today i’m going to explain about Map Interface in Java. We started the these article series with Collections and Map Interface is a valuable part of that Collection Framework. But Map interface is not a subtype Collection Interface. It behaves little bit different.
Map stores elements key-value pairs. You can access to values with key. It can not contains duplicate keys. Each key has only one value. Some of Map implementations can allow null value(key or value) but some of not. Example, HashMap and LinkedHashMap allow that but TreeMap doesn’t allow.

Lets take a look Map interface methods in shortly.

public Object put(Object key, Object value) : This method is used to insert an entry in this map
public void putAll(Map map) : This method is used to insert a map in this map.
public Object remove(Object key) : This method is used to remove an entry for key
public Object get(Object key)  : This method is used to get value for key
public boolean containsKey(Object key) : This method is used to check key is exists.
public Set keySet() : This method returns containing all keys
public Set entrySet() : This method returns containing all keys and values.

Here is the example of code about Map Interface.

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main {

    public static void main(String... args) {
        Map<String, Integer> nameAgeMap = new HashMap<>();
        // Adding elements to map
        nameAgeMap.put("Ufuk", 26);
        nameAgeMap.put("Halis", 26);
        nameAgeMap.put("Alice", 30);

        write(nameAgeMap);
        System.out.println("------------------------------------");
        //Removing element from map
        nameAgeMap.remove("Ufuk");
        write(nameAgeMap);
        System.out.println("Map contains key Ufuk : " + nameAgeMap.containsKey("Ufuk"));
    }

    private static void write(Map map) {
        Set<Map.Entry> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println("Key : " + entry.getKey());
            System.out.println("Value : " + entry.getValue());
        }
    }
}

Collections – Giriş

Merhabalar, bu yazımda Java‘da Collections‘a giriş yapacağım ve sonraki yazı serilerinde bu framework içinde bulunan class‘ları ve interface‘leri anlatmaya devam edeceğim.

Collections, Java içerisinde büyük bir öneme sahiptir ve bu yüzden Java‘da öğrenilmesi gereken en önemli alanlarından biridir. Sonuçta kodlama yaparken kullandığımız List, Map, nedir, nasıl çalışır, avantajları vs gibi durumlarınların bilinmesi bizi daha efektif kod yazmaya iter.

Java‘da Collections‘dan önce, array, vector ve hashtable bulunmaktaydı. Bu 3 farklı collection‘nın ortak bir interface‘i yoktu. Yani her biri için farklı metotlar, farklı member‘lar anlamına geliyordu. Bu da programcı için bir dezavantaja dönüşmekteydi. Bu daha da ileride işkenceye dönüşmemesi için Java‘yı geliştirenler, ortak bir interface‘e sahip ve önceki Collection‘ların problemlerini çözecek bir framework tasarladılar ve böylece Collection Framework‘ü doğmuş oldu.

Collection Framework‘ünün avantajlarından şöyle bahsedebiliriz.

  • Tutarlı(Consistent) bir API.
  • Programlama efortunu kısaltma.
  • Programlama hızını ve kalitesini arttırma.

Core olarak yer alan interface‘leri incelersek;

             Collection                Map
         /     /    \      \            |
        /      /      \     \           |
     Set    List    Queue  Dequeue   SortedMap
     /
    /
 SortedSet

Collection : En tepedeki interface’dir. add(), remove(), contains(), isEmpty(), addAll() gibi metotları bulunmaktadır.

Set : Duplicate eleman yer almaz. Örnek olarak HashSet ve TreeSet(SortedSet sınıfını implements eder) verilebilir.

List : Duplicate eleman içerebilir. Elemanlar sıralıdır. Örnek olarak LinkedList ve ArrayList verilebilir.

Queue : FIFO prensibine göre hareket eder.

Dequeue : LIFO ve FIFO prensiplerini destekler.

Map : Elemanları keyvalue şeklinde saklar. Duplicate elemanlara izin vermez. Örnek olarak HashMap ve TreeMap(SortedMap interface’i implement eder.) verilebilir.

Collections giriş olarak şimdilik bu kadar, sonraki yazılarda yer alan interface‘leri örnekler ile incelemeye başlayacağız.

Reflection API

Merhabalar, bu yazımda Java’daki Reflection API‘ye kısaca değineceğim. Reflection API, çalışma zamanı anında, metotların, sınıfların ve interface’lerin davranışlarını incelemek veya değiştirmek için kullanılır.

Reflection, bir nesnenin hangi sınıfa ait olduğu ve nesneye ait hangi metotların koşturulabileceği hakkında bilgiler verir ve bunu runtime anında yapar.

getClass() metoduyla nesnenin ait olduğu sınıfın ismine erişilebilir.
getConstructors() metoduyla nesnenin ait olduğu sınıfın public constructor‘larına erişilebilir.
getMethods() metoduyla nesnenin ait olduğu sınıfın public metodlarına erişilebilir.

Eğer bir sınıfın sahip olduğu private field‘lara veya metotlara erişmek istersek şu şekilde ilerleyebiliriz.
Class.getDeclaredField(FieldName) ile Field nesnesini aldıktan sonra Field.setAccessible(true) yaparak, access modifier‘ından bağımsız olarak metot veya field‘a erişim sağlanabilir.

Reflection‘lar sahip oldukları bu özellikleriyle bize genişletilebilirlik(Extensibility) anlamında avantajlar sağlamaktadır. Ancak bir nesnenin hangi sınıfa ait olduğu bilip Reflection API kullanmadan yapmak performans açısından daha iyidir. Bu nedenle sıklıkla kullanılan kodlarda Reflection API kullanılmasından kaçınılmalıdır. Ayrıca Reflection abstraction kavramını da yok etmeye meyillidir.

Yukarıda bahsettiklerimi basit olarak kodda aşağıdaki gibi uygulayabiliriz.

ReflectionTest.java

public class ReflectionTest {
    private String str;

    public ReflectionTest() {

    }

    public void method1() {
        System.out.println("Method 1 worked");
    }

    public void method2() {
        System.out.println("Method 2 worked");
    }

    public String getStr() {
        return str;
    }
}

Main.java

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
    public static void main(String... args) throws
            NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
        ReflectionTest test = new ReflectionTest();
        Class clazz = test.getClass();
        System.out.println("test object class name : " + clazz.getName());
        System.out.println("test object class constructor name : "
                + clazz.getConstructor().getName());
        for (Method method: clazz.getMethods()) {
            System.out.println("Method Name : " + method.getName());
        }
        Method method1 = clazz.getMethod("method1");
        //calling method1
        method1.invoke(test);

        //private field accessing and set new value
        Field field = clazz.getDeclaredField("str");
        field.setAccessible(true);
        field.set(test, "TEST");
        System.out.println("str value : " + test.getStr());
    }
}

Java – Static Blocks

Merhabalar, bu yazımda Java‘da yer alan static blocks‘tan kısaca bahsedeceğim. Bu bloklar bir sınıfın static initializations‘ı olarak kullanılır. Static bloktaki kod yalnızca bir kere çalıştırılır ve bu bloklar construct‘lardan önce çalışır. Aşağıda bu static blok olayını anlatan kod yer almaktadır.

class Example {
    static int i;
    static {
        i = 10;
        System.out.println("Static block");
    }
    Test(){
        System.out.println("Constructor");
    }
}
class Main {
    public static void main(String args[]) {
        Example e1 = new Example();
        Example e2 = new Example();
    }
}
Programı çalıştırdığımızda aşağıdaki gibi bir çıktı olacaktır ve görüldüğü Example sınıfından nesne oluştururken static blok bir kez ve constructer’dan önce çalıştı.
Static block
Constructor
Consturctor

JVM Mimarisi

Merhabalar, bu yazımda Java Virtual Machine‘nin(JVM) hakkında bildiklerimi aktarmaya çalışacağım. Öncelikle google’a jvm yazdığınızda çıkan wikipedia sayfasında yer alan, JVM’in genel yapısını gösteren bir resimle başlıyorum.

1024px-jvmspec7

Resimden de görülebileceği gibi 3 temel bölüm var diyebiliriz. Class Loader, JVM Memory ve Execution Engines..

Temel olarak JVM‘in görevi Java uygulamalarını çalıştırmaktır diyebiliriz. Bir Java kodundaki ana metodu(main method) çağırır. JVM, JRE‘nin(Java Run Enviroment) bir parçasıdır.

Java uygulamaları WORA(Write Once Run Everywhere) prensibine sahiptirler. Geliştirici yazdığı Java kodunu, herhangi bir JVM yüklü platformda çalıştırabileceği anlamına gelir. Şimdi yukarıdaki resimde bahsettiğimiz 3 temel bölümü inceleyelim.

1. Class Loader Subsystem(Sınıf Yükleyici Alt Sistemi)

Bu bölümde ana 3 aktivite bulunur. Loading, Linking  ve Initialization..

1.1 Loading

Java‘da *.java uzantılı dosyalar derlendiğinde *.class uzantılı hale gelir. Class Loader. *.class uzantılı dosyaları okuyarak ikili verileri üretip metot bölgesine kaydeder. Her *.class dosyası için JVM, aşağıdaki bilgileri saklar.

  • Yüklenen sınıfın tam adı ve üst sınıfını.
  • .class dosyasının Class veya Interface veya Enum ile alakalı olup olmadığını.
  • Değişkenler ve metot bilgilerini.

*.class yükleme işleminden sonra, JVM bu .*class‘ı temsil etmek için heap memory‘de Class tipinde bir nesne oluşturur. Bu Class tipi java.lang paketinde tanımlanmıştır ve bu Class, programcı için nesne hakkında bilgi almalarda kullanılabilir.(Sınıfın adı, Parent adı, değişkenleri, metotları vs.)

Her yüklenen *.class dosyası için yalnızca bir Class nesnesi oluşturulur.

1.2 Linking (Bağlama)

Bu aşamada da verification, preparation ve opsiyonel olarak da resolution işlemleri uygulanır.

Verification(Doğrulama) : *.class dosyalarının doğruluğunun yapılması aşamasıdır. Doğrulamadan geçilemezse run-time java.lang.VerifyError hatası verir.

Preparation(Hazırlık) : JVM gerekli sınıf değişkenkerini memory’de yer ayırır ve varsayılan değelerini atar.

1.3 Initialization (Başlatma)

Bu aşamada, tüm statik değişkenler ve varsa statik blokta tanımlanan değerleriyle atanırlar. Genel olarak üç tane sınıf yükleyici vardır.

Bootstrap Class Loader(Önyükleme Sınıfı Yükleyicisi) : Her JVM uygulamasında güvenilen sınıfları yükleyebilen bir önyükleme sınıfı yükleyicisi olmalıdır. Bu loader, JAVA_HOME/jre/lib dizininde bulunan çekirdek java API sınıflarını yükler. Bu yol yaygın olarak önyükleme yolu olarak bilinir. Buradaki API’ler C, C ++ gibi yerel dillerde yazılmışlardır.

Extension Class Loader(Uzantı sınıfı yükleyicisi) : Önyükleme sınıfı yükleyicisinin child’dıdır. JAVA_HOME/jre/lib/ext (Uzantı yolu) uzantı dizinlerinde bulunan sınıfları veya java.ext.dirs sistem özelliği tarafından belirtilen başka bir dizini yükler. Java’da sun.misc.Launcher $ ExtClassLoader sınıfı tarafından uygulanmaktadır.

System/Application class loader(Sistem / Uygulama sınıfı yükleyici) : Uzantı sınıfı yükleyicinin child’dıdır.. Sınıfları uygulama sınıfı yolundan yüklemekle sorumludur. İçinde java.class.path ile eşlenen Environment Variable‘i kullanır. Ayrıca, Java’da sun.misc.Launcher $ ExtClassLoader sınıfı tarafından da uygulanır.

2. JVM Memory

JVM mimarisini 2. bölümüdür. Şekilde de görüldüğü gibi 5 alandan oluşmaktadır.

Method Area : Metod alanında, sınıf adı, ana sınıf adı, değişkenleri, metotları vs. gibi bilgiler saklanmaktadır. JVM başına yalnızca bir yöntem alanı vardır ve paylaşılan bir kaynaktır.

Heap Area : Tüm nesnelerin bilgilerini saklar.JVM başına bir heap alanı vardır ve paylaşılan bir kaynaktır.

Stack Area : Her iş parçacığı için, JVM burada saklanan bir çalışma zamanı yığını oluşturur. Bu yığının her bloğu, yöntem çağrılarını saklayan etkinleştirme kaydı / yığın çerçevesi olarak adlandırılır. Bu yöntemin tüm yerel değişkenleri, karşılık gelen çerçevede saklanır. Bir iş parçacığı sonlandıktan sonra çalışma zamanı yığını JVM tarafından yok edilir. Paylaşılan bir kaynak değildir.

PC Registers : Bir iş parçacığının geçerli yürütme talimatının adresini saklar.

Native Method Stacks : Her bir iş parçacığı için ayrı yerli yığın oluşturulur. Yerel metod bilgilerini depolar.

3. Execution Engine

Bu aşama da her *.class dosyalarını satır satır okur ve çalıştırır.3 aşaması vardır.

Interpreter : Bayt kodu satır satır olarak yorumlar ve yürütür. Buradaki dezavantaj, bir yöntem birden çok kez çağrıldığında, her yorumlama gerekliliğidir.

Just In Time Compiler : Interpreter verimliliğini artırmak için kullanılır.Tüm bayt kodunu derleyip yerel koda çevirir, böylece Interpreter tekrarlanan metod çağrılarını gördüğünde, JIT bu bölüm için doğrudan yerel kod sağlar, böylece yeniden yorumlama gerekli değildir, ve verimlilik artmış olur.

Garbage Collector : Referans edilmemiş nesneleri yok eder.

Builder – Tasarım Kalıpları

Merhabalar, bu yazımda Oluşturucu Tasarım Kalıplarından Builder Tasarım Kalıbına değineceğim. Builder, nesne üretim sürecinde değişik parçalar birleştirilip istenilen tipte nesne oluşumunu amaçlamaktadır. Klasik olarak Java’da bir nesne oluşturmak istediğimizde aşağıdaki kod bloklarına benzer şekilde nesnemizi oluştururuz.

Person person = new Person();
Person person2 = new Person("Ufuk", "Halis", 25);

Görüldüğü gibi Person sınıfı 2 tane constructer’a sahip ve nesne oluşturmak istendiği zaman bu ikisinden birini tercih etmek zorundayız. Peki ya bu sınıfta sadece Ad ve Soyad geçecek biçimde nesne oluşturmak istersek, evet yolu basit gidip bu iki parametreli yeni constructer’ı Person sınfında yaratmak. Ancak gereksinimler iyice değiştiği zaman ne olacak, Ad-Yaş, Soyad-Yaş gibi. Person sınıfı constructer’dan geçilmeyecek 🙂 İşte builder bu durumda yardımımıza giriyor. Nesnemizi oluştururken sadece set etmek istediğimiz alanları ayarlıyoruz ve nesnemizi yaratıyoruz. Hem kodun okunuşu bakımından hem de esnekliği bakımından daha iyi bir hale gelmiş oluyor. Person sınıfımızı Builder pattern’e uygun olacak şekilde tasarlayalım.

Person.java

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String address;
    private String telephone;

    public static class Builder {
        private Person person;

        public Builder() {
            person = new Person();
        }

        public Builder setAddress(String address) {
            person.address = address;
            return this;
        }

        public Builder setAge(int age) {
            person.age = age;
            return this;
        }

        public Builder setFirstName(String firstName) {
            person.firstName = firstName;
            return this;
        }

        public Builder setLastName(String lastName) {
            person.lastName = lastName;
            return this;
        }

        public Builder setTelephone(String telephone) {
            person.telephone = telephone;
            return this;
        }

        public Person build() {
            return person;
        }
    }

}

Main.java

public class Main {

    public static void main(String[] args) {
        Person person = new Person.Builder().
                        setFirstName("Ufuk").
                        setLastName("Halis").
                        setAge(25).build();
        Person person2 = new Person.Builder().build();
    }
}

Görüldüğü gibi Person sınıfında bir Builder sınıfı yarattık ve Person sınıfının sahip olduğu değerleri bu Builder sınıfı içerisinde set lemiş olduk. Person sınıfındaki tüm değerlerimiz optional bir bakıma, bazı durumlarda Builder ile bir nesne yaratmak istiyoruz ancak olmazsa olmaz başlangıç değerleri istiyorsak, bunuda Builder’ın constructer’ında yapabiliriz. Böylece o alanlar required hale gelir.

Builder Tasarım kalıbı, karmaşık nesne oluşturma süreçlerinden kurtararak değişik parametreler ile nesne oluşturmak istenildiğinde kullanılması tercih edilir.

Bir yazının daha sonuna gelmiş bulunuyoruz böylelikle 🙂

Mercurial – Versiyon Kontrol Sistemi

Bu yazımda versiyon kontrol sistemlerinden biri olan Mercurial nedir nasıl kullanılır gibi bilgiler vereceğim.
VCS(Version control system), yazılımcıların bir proje üzerinde ortak bir şekilde çalışabilmesine olanak sağlayan, gerek duyulduğunda eski kodlara ulaşılabilmesine yardımcı olan bir sistem olarak tanımlayabiliriz. En bilindikleri Git, SVN, Mercurial şeklinde gider. Ama şuan en popüler olarak kullanılan dünyada ve ülkemizde Git‘ dir.
Bense gerek alışkanlık gerekse daha kolay rahat olduğum Mercurial sistemini bu yazımda nasıl kullanıldığını bir örnek ile açıklayacağım.

Öncelikle sitesinden güncel sürümü işletim sistemimize uygun olanı indirelim. Link : https://www.mercurial-scm.org/
Projeyi atacağım yer Bitbucket sitesidir. Avantajı olarak hem Git hem de Mercurial destekleyebilmesi ve ayrıca private(özel-gizli) repo oluşturabilmeyi olanak sağlamaktadır. Link : bitbucket.org

IDE olarak Eclipse Mars‘ı kullanıyorum. Size Netbeans veya Intellij seçebilirsiniz. İndirdiğimiz dosyayı kurduktan sonra terminal ve cmd ‘ yi açarak hg –version komutunu kullanarak kurulup kurulmadığını görebiliriz. Ardından Eclipse marketplace ‘ e girerek resimdeki gibi Mercurial plugin’i yüklüyoruz.

1

Ardından bitbucket sitesinde Create Repository ‘ den yeni bir repo oluşturuyoruz.

2

Sonra Eclipse ‘ te yeni bir proje oluşturalım. Oluşturduktan sonra proje üzerine sağ tıklayıp Team->Share Project seçelim.

3

Seçeneklerden Mercurail seçip işlemi bitirelim. Artık bir projemize Mercurial‘ı uyguladık ve hemen dikkatimizi çeken projemizin üstünde bir ikon geldi. Bu commit ‘ lemediğimiz dosyaların var olduğu anlamına gelmektedir.

Bu sistem şöyle işler. Bir uzak repomuz vardır bir de local repomuz vardır ve bir de çalıştığımız workspace. Bir dosya eklersek, çıkarırsak veya değiştirirsek bunları commit’lemediğimiz sürece değişiklikler workspace’de kalır. Commitleyince local repomuz güncellenir. Ardından bu commit’i pushlarsak uzak repomuz güncellenir. En basit mantık böyle işlemektedir. Yaptığımız değişikliği Revert seçeneğiyle geri alabiliriz. Ancak commit yapmadığımız sürece revert yapabiliriz.

Ardından Eclipse->Window->Show View->Other kısmına gelip Mercurial Repositories seçelim. Aşağıdaki gibi bir ekran gelicektir.

4

Kırmızı alanla belirtilen yeri seçelim ve gelen ekranı bitbucket username, password ve repo ‘ url’i girin.

5

Ardından Team->Synchronize With seçeneğini seçip gelen ekranda combobox’tan girdiğimiz url’i seçip Finish diyelim ve şuan projemiz uzak repo ile bağlantılı hale getirdik.

Ardından basit bir Java main sınıfı projemize dahil edelim.

6

Ardından Team->Commit diyelim. Bir commit mesajı verip işlemi tamamlayalım. Bunu yaptıktan sonra projemiz üzerindeki o siyah ikon gitmiş olacak ve yerine 1 veya yaptığımız commit sayısına bağlı olarak bir sayı gelecektir. Synchronize tab’i altında da aynı işlemleri gerçekleştirebilirsiniz.

7

Ardından yine aynı yeri kullanarak bu sefer Push seçeneğini seçelim. Evet şimdi bitbucket hesabınızı kontrol ettiğinizde dosyları orada görebileceksiniz.

8

Repo link : https://bitbucket.org/uhalis/mercurialtest/

Son olarak önemli olan bir dosya dan bahsedeceğim. .hgignore isimli dosya, commit-push ‘ a girmesini istemediğimiz klasör ve dosya tanımlamalarını içerir. Genel olarak Eclipse kullanırken .settings klasörü, bin klasörü .classpath ve .project dosyalarını atmamıza gerek yoktur. Bunlar her pc’ye göre değişebileceğinden exclude edilir. Bizim için önemli olan kod ve lib’lerdir.
Bir dosyayı ignore etmek için dosya üzerine sağ tıklayıp Team->Ignore seçebiliriz. Ayrıca .hgignore dosyasını da ignore edebiliriz.

Evet bu yazımda Mercurial nasıl kullanılır hakkında elimden geldiğince yazdım. Sonraki yazılarda görüşmek üzere..

Test edilmeyen kod tuhaflaşır…

Java 8 Lambda Nedir ve Nasıl Kullanılır?

Merhaba, bu bloga 2.yazım olarak JDK 8 ‘ de adını vermiş (Project Lambda), JDK 8 ‘ in getirdiği en önemli özelliklerden biri olan Lambda ‘ ların ne olduklarını ve basit olarak nasıl kullanıldıklarını anlatacağım.

 

Lambda , programlama dili çerçevesinde Lambda, anonim tekil görevler olarak değerlendirilebilir. Lambda deyimleri (Lambda fonksiyonları da denebilir), referans verilebilir ve tekrar tekrar kullanılabilirdir. [1] Temelde belli bir giriş değerine karşılık bir sonuç üretirler.

Kullanımını örnekler üzerinden devam edelim..

Kod 1 : Döngü

Basit bir string listesi içindeki verileri konsola yazdırırken aşağıdaki gibi bir yol izleriz.


String[] strArray = {"Bruce Wayne", "Jason Todd", "Dick Grayson", "Tim Drake", "Barbara Gordon"};
List characters = Arrays.asList(strArray);
for (String character : oyuncular) {//Bildigimiz for dongusu
System.out.println(character);
}

Lambda’lar ile for döngüsünü aşağıdaki şekilde olmaktadır.


characters.forEach((character) -> System.out.println(character));

Kod 2 : Limit
Listemizde 5 eleman bulunmakta biz sadece 3 tanesini yazdırmak istersek aşağıdaki kod tam da istediğimiz işi yapacaktır.


characters.stream()
.limit(3)
.forEach((character) -> System.out.println(character));

Kod 3 : Sıralama
İsme göre sıralama yapmak istersek aşağıdaki gibi bir kod yazılabilir.


List sortedCharacters = characters
.stream()
.sorted((c1, c2) -> (c1.compareTo(c2)))
.collect(toList());

Kod 4 : Thread
Normal olarak yazdığımız thread aşağıdaki gibi tek satıra indirgenmektedir.


new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Lambda!!");
}
}).start();

//lambda ‘ lar ile


new Thread(() -> System.out.println("Lambda!!")).start();

 

Evet çok basit örnekler ile lambda ‘ ların kullanımı bu şekilde. Lambda ‘ lar JDK 8 ile gelmektedir bu yüzden sisteminizde JDK 8 yüklü olması gerekiyordu.
Ancak retrolambda adı verilen proje sayesinde, lambda ‘ ları JDK 5,6 ve 7 versiyonlarında da kullanılabilmesine olanak tanıyor. Proje linki : https://github.com/orfjackal/retrolambda
İlerleyen zamanlarda bu kütüphanenin nasıl kullanıldığına dair bir yazı yazmayı düşünüyorum.

Şimdilik bu kadar.. 🙂

Test edilmeyen kod tuhaflaşır…