Tüm yazılar

Java 8 Yenilikleri – Bölüm 2

java8-bolum2
İçindekiler

Bir önceki yazıda Java 8 ile gelen yeniliklerden olan default metodları, fonksiyonel arayüz kavramını, lambda ifadelerini ve metod referansı konusundan bahsetmiştim. Bu yazıda ise lambda ifadelerinde kullanmak üzere Java tarafından hazırlanmış yardımcı fonksiyonel arayüzlerden bahsedeceğim.

Yardımcı Fonksiyonel Arayüzler

Farklı tiplerdeki lambda ifadelerine temel oluşturmak için java.util.function paketi altında fonksiyonel arayüzler bulunmaktadır. Bunları 4 kategoriye ayırabiliriz.

  • Consumer : Paremetre alıp işlem yapar ve geriye sonuç döndürmez.
    • void accept(T t);
  • Predicate: Parametre alır ve şarta bağlı olarak boolean sonuç döndürür.
    • boolean test(T t);
  • Supplier: Hiç parametre almaz ancak T tipinde değer döndürür.
    • T get();
  • Function: Parametre alır, işler ve geriye bir sonuç üretir.
    • R apply(T t);

1. Consumer Arayüzü

Consumer yani türkçesi tüketici olan bu arayüz, jenerik olan T tipinde (yani isteğe göre herhangi bir Java tipi alabilir) bir parametre alan ve aynı zamanda geriye sonuç döndürmeyen bir metoda sahiptir.

Consumer tek bir soyut metoda sahip olduğundan dolayı funcitonal interface’dir. Temel olarak yaptığı iş kendisine verilen lambda ifadesini yerine getirmektir. Deyim yerindeyse bu işi tüketmektedir.

Basit bir örnekle başlayalım;

public class EasyConsumerExample {
    public static void main(String[] args) {
        // accept() metoduna String tipte bir parametre göndererek çalışmasını sağladık.
        Consumer<String> consumer = name -> System.out.println("İsminiz : " + name);
        consumer.accept("Ömer Faruk"); // Çıktı : İsminiz : Ömer Faruk
    }
}

EasyConsumerExample.java · GitHub Gist

Daha kapsamlı bir örnekle, Consumer arayüzü içerisinde default olarak tanımlanmış andThen() metodununun kullanılışını görelim. Bu metod 2 Consumer’ı birbirine zincirleyerek accept() metodu çağrıldığında sıralı olarak çalışabilmelerini sağlar.

public class ConsumerExample {

    public static void main(String[] args) {

        Person person = new Person("Ömer", "Gençx");
        System.out.println(person); // Çıktı : Person{name='Ömer', surname='Gençx'}
        
        // Tip olarak Person sınıfı belirtildi. Lambda ifadesiyle person nesnesinin isim alanı değiştirildi.
        Consumer<Person> updateName = p -> p.setName("Faruk");
        updateName.accept(person);  // Lambda ifadesiyle verilen görev yerine getirildi, geriye değer döndürülmeyecek.
        System.out.println(person); // Çıktı : Person{name='Faruk', surname='Gençx'}

        // andThen() metoduyla iki Consumer'ı birbirine zincirledik.
        // Dipnot : Birinci ifade de herhangi bir hata olması durumunda bir sonraki iş çalışmayacaktır.

        // Mesela isim bilgisini güncelledikten sonra soyisim bilgisini güncelleyelim.
        Consumer<Person> updateName2 = p -> p.setName("Ömer Faruk");
        updateName2 = updateName2.andThen(p -> p.setSurname("Genç"));
        updateName2.accept(person);
        System.out.println(person); // Çıktı : Person{name='Ömer Faruk', surname='Genç'}
    }
}

ConsumerExample.java · GitHub Gist

public class Person {

    private String name;
    private String surname;

    public Person(String name, String surname) {
        this.name = name;
        this.surname = surname;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", surname='" + surname + '\'' +
                '}';
    }
}

Person.java · GitHub Gist

Consumer arayüzünü kullanırken jenerik tip kullanıyorduk, ancak primitive tip kullanmak istersek Java bizim için yardımcı arayüzleri hazırlamış. Bunlar;

  • IntConsumer: Parametre olarak int değer alır.
  • LongConsumer: Parametre olarak long değer alır.
  • DoubleConsumer: Parametre olarak double değer alır.
  • BiConsumer: T ve U tiplerinde iki parametre alır .
  • ObjIntConsumer: T ve int tiplerinde iki parametre alır.
  • ObjDoubleConsumer: T ve double tiplerinde iki parametre alır.
  • ObjLongConsumer: T ve long tiplerinde iki parametre alır.

Not : Consumer arayüzü, Iterable arayüzünün içerisinde bulunan Collection’lar ile birlikte kullanılan forEach metodunda kullanılmaktadır.


2. Predicate Arayüzü

Türkçesi doğrulamak olan Predicate arayüzü, Consumer arayüzü gibi T tipinde bir girdi alır ve kendisine sunulan şartın sağlanıp sağlanmadığını kontrol ederek geriye “true ya da false” değer döner. Boolean dönüş değerine sahip bir işlev olarak düşünülebilir. Filtreleme ve gruplama gibi işlemlerde kullanılır.

Basit bir örnek yapalım.

public class PredicateExample {
    public static void main(String[] args) {

        Predicate<Integer> isAEvenNumber = number -> number % 2 == 0 ;
        boolean result = isAEvenNumber.test(60);
        System.out.println("Girilen sayı çift mi ? " + result); // true

        Predicate<String> isALongSentence = (String sentence) -> sentence.length() > 60;
        boolean sonuc = isALongSentence.test("Bu uzun bir cümle ama uzunluğu 60 karakterden uzun değil.");
        System.out.println("Girilen cümle 60 karakterden uzun mu ?" + sonuc); // false

    }
}

PredicateExample.java · GitHub Gist

Predicate arayüzü, test() metodu haricinde içerisinde 3 metod daha barındırır. Bu metodların yaptıkları iş şöyledir.

  • and(): İki Predicate’i birleştirir ve mantıkta ki ve (&&) işlemine tabi tutar.
  • or(): and() ile aynıdır ancak bu sefer mantıkta ki or işlemine tabi tutulur.
  • negate(): Not ile aynı işlevi görür. Sonuç neyse tersini geri döndürür.

Bu metodların kullanıldığı küçük bir örnek yapalım.

public class OtherMethodsInPredicateInterface {
    public static void main(String[] args) {

        Predicate<String> predicate = name -> name == "Faruk" ;
        predicate = predicate.and(name -> name.length() == 6);
        // test() metodu çağrıldığında aslında -> name == "Faruk" && name.length == 6 işlemi yapılacak.
        // && işlemi olduğundan dolayı şartın birisi sağlanmayacağından false dönecek.
        System.out.println( predicate.test("Faruk")); //

        // or için denersek;
        Predicate<String> predicate2 = name -> name == "Faruk";
        predicate2 = predicate2.or(name -> name.length() == 6); // name == "Faruk" || name.length == 6 işlemi yapılacak.
        System.out.println(predicate2.test("Faruk")); // or işleminde bir şart sağlansa bile true dönecektir.
        System.out.println("Predicate'den dönen sonucun tersini alır : " + predicate2.negate().test("Faruk"));
    }
}

OtherMethodsInPredicateInterface.java · GitHub Gist

Predicate arayüzü aynı zamanda primitive tipte değerler alabilecek versiyonlarıda bulunmakta.

  • BiPredicate: T ve U tiplerinde iki parametre alır boolean değer üretir.
  • IntPredicate: Parametre olarak int değer alıp sonuç üretir.
  • DoublePredicate: Parametre olarak double değer alıp sonuç üretir.
  • LongPredicate: Parametre olarak long değer alıp sonuç üretir.

3. Supplier Arayüzü

Supplier kelimesinin türkçesine baktığımızda “ihtiyacı karşılayan, satıcı” anlamlarının olduğunu görüyoruz. Bu arayüz, Consumer arayüzünün tam tersini yapar. Yani girdi olarak bir şey almaz ancak geriye bir değer döndürür.

Mesela, Person adında bir classımızın olsun ve yalnızca name adında bir propertye sahip olduğunu düşünelim. Supplier arayüzü yardımıyla bu sınıftan bir nesne oluşturulım. Constructor’ına parametre olarak isim bilgisini verelim.

public class Person {

    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

Person.java · GitHub Gist

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Person> supplier = () -> new Person("Faruk");
        Person person = supplier.get();
        System.out.println(person);

        // BooleanSupplier örneğine bakalım.
        BooleanSupplier isLogin = () -> false;
        System.out.println(isLogin.getAsBoolean());
    }
}

SupplierExample.java · GitHub Gist

Primitive tipler ve boolean değer içinde yardımcı alt arayüzler bulunmaktadır.

  • BooleanSupplier: Geriye boolean değer döndürür.
  • IntSupplier: Geriye int değer döndürür.
  • DoubleSupplier: Geriye double değer döndürür.
  • LongSupplier: Geriye long değer döndürür.

4. Function Arayüzü

Function arayüzü, jenerik olarak T tipinde bir parametre alır, verilen işi yürütür ve ardından R tipinde bir değer döndürür.

Örnekler üzerinden anlatmaya çalışayım.

public class FunctionExample {
    public static void main(String[] args) {

        // Integer bir sayı giriliyor ve bu sayı String'e dönüştürülüyor.
        Function<Integer,String> function = number -> number.toString();
        String functionResult = function.apply(100);
        System.out.println(functionResult + 100); // Çıktı : 100100 olur çünkü girilen sayı String'e dönüştü.

        // Girilen parametre ile dönüş tipi aynı olduğu durumda UnaryOperator kullanabiliriz.
        // UnaryOperator arayüzü Function arayüzünü kalıtmaktadır.
        // String bir cümle giriliyor ve cümledeki her harf büyük harfe dönüştürülüyor.
        UnaryOperator<String> unaryOperator = s -> s.toUpperCase();
        String unaryOperatorResult = unaryOperator.apply("Merhaba UnaryOperator !");
        System.out.println(unaryOperatorResult); // Çıktı : MERHABA UNARYOPERATOR !

        // T ve U tiplerinde iki parametre alır, R tipinde değer döndürür.
        // Function'dan tek farkı burada 2 parametre alabiliyor olması.
        BiFunction<Integer,Integer,Double> biFunction = (sayi1,sayi2) -> {
            Integer integerValue = sayi1 + sayi2;
            Double doubleValue = integerValue.doubleValue();
            return doubleValue;
        };

        Double biFunctionResult = biFunction.apply(5, 5);
        System.out.println(biFunctionResult); // Çıktı : 10.0 olur.
    }
}

FunctionExample.java · GitHub Gist

Function arayüzünün çeşitleri oldukça fazladır. Yukarıdaki örnekte BiFunction ve UnaryOperator’den bahsettim ancak dilerseniz buradan tüm Function içeren sınıfları bulabilir ve metodları inceleyebilirsiniz.


Yazımı burada sonlandırıyorum. Bir sonraki bölüm Stream API hakkında olacak. Diziler ve Collection’lar üzerinde çalışan ve mükemmel kabiliyetleri olan Stream API’nin detaylarına gireceğiz. 🚀

Umarım bu yazı işinize yaramıştır. Herkese iyi çalışmalar dilerim. 👨🏻‍💻

Kaynaklar

  1. https://medium.com/@metinalniacik/javada-predicate-functional-interface-bb502cc864a9
  2. https://dogukanhan.com/category/java/java-util-function/
  3. https://kodedu.com/java-8-ebook/
  4. http://eherrera.net/ocpj8-notes/04-lambda-built-in-functional-interfaces#use-the-built-in-interfaces
  5. https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
  6. https://www.baeldung.com/java-8-functional-interfaces