Java 8 -- STREAM EXAMPLES

List<person> list = new ArrayList<>(); list.add(new Person(1, "John")); list.add(new Person(2, "Mary")); list.add(new Person(3, "Peter")); // id si 1den buyuk olanlari bulmak icin list = list.stream().filter(person -> person.getId() >1).collect(Collectors.toList()); System.out.println(list.size()); // sadece listedeki id leri gostermek icin List<integer> idList = list.stream().map(person -> person.getId()).collect(Collectors.toList()); System.out.println(idList);


Asagidaki sekilde bir kod NullPointerException verir. Cunku array initialize edilmeden index teki degerine ulasilmaya calisiliyor.

Integer[] arr = new Integer[5]; System.out.println(arr[3].toString());

Bunu onlemek icin Optional kullanabiliriz.

Integer[] arr = new Integer[5]; Optional<integer> arrOptional = Optional.ofNullable(arr[3]); if (arrOptional.isPresent()) { System.out.println(arr[3].toString()); }

Bu sekilde yazdigimizda ise 3.index bos degilse if icine girip 3.indexin degerini yazar. Bos ise nullpointerexception vermeyecek, hic bir sey yapmadan hatasiz sonlanacaktir.

Eger lambda expression tek satirsa { suslu paranteze gerek yok.
Return type ve input type a gerek yok.
method un access modifier icermesine gerek yok(public, private vs)
Lambda expression in bir degiskene atanmasi gerekir.

public void showMsg(String name){
    System.out.println("Hello "+ name);
}

Bu kod satiri su hale gelir:

OrnekClass ornekClass = name -> System.out.println("Hello "+ name);

FunctionalInterface

Sadece bir tane abstract method iceren interface dir. Interface in uzerine @FunctionalInterface eklenir.

Ayni islemin Java8 den once ve Java 8 ile nasil yapildgini gosteren 2 resim asagidadir. Java8 ile interface implementation icin farkli bir sinifa ihtiyac duymayiz, gerekli sinifta implement edebiliriz.

Function Interface

FunctionInterface bir input ve output tan olusan interface dir.

Function<T, R> seklinde T: input, R: output type i belirtir. Asagida sayinin karesini bulan bir ornek var hem java8 den once hem de java8 ile.  Kare bulmak icin bir tane input girer ve sonucta bir output aliriz. Bu yuzden FunctionInterface bize uygundur. Avantaji ise gordugumuz gibi Java8den once islemi yapmasi icin yeni bir method olusturduk. Java8 ile yeni bir method olusturmaya gerek olmadan predefined methodlarla ihtiyacimizi karsiladik.

package com.example; import java.util.function.Function; public class FunctionalInterfaceEx1 { public static void main(String[] args) { beforeJava8(); fromJava8(); } private static void beforeJava8() { Integer n = 5; Integer squareOfNumber = calculateSquare(n); System.out.println("Square of number is :" + squareOfNumber); } private static Integer calculateSquare(Integer n) { return n * n; } private static void fromJava8() { Function<Integer, Integer> function = n -> n * n; System.out.println("Square of number is :" + function.apply(5)); } }

Output: Square of number is :25
             Square of number is :25

Function Interface in apply disinda diger bir default methodu olan andThen() methoduna bakalim.  Eger bir method output unun diger bir methoda input olmasini istiyorsak andThen() kullaniriz.

package com.example; import java.util.function.Function; public class FunctionInterfaceEx2 { public static void main(String[] args) { Function<String, String> function1 = input1 -> input1.toUpperCase(); Function<String, String> function2 = input2 -> input2.concat(" WORLD"); System.out.println("Function1: " + function1.apply("hello")); System.out.println("Function2: " + function1.andThen(function2).apply("hello") ); } }

Output : Function1: HELLO
              Function2: HELLO WORLD

Diger bir method ise compose() . andThen in tam tersi seklinde calisir. Once diger method calisir. Yukardaki ornek icin konusursak once function2 calisacak yani "hello WORLD" elde edicez daha sonra function1 calisip hepsini uppercase yapicak ve "HELLO WORLD" elde edicez.

Kullanimi ise ayni andThen seklinde sadece yerine compose yazilir.

Supplier Interface 

Burada ise sadece output vardir. Herhangi bir input yoktur.

package com.example; package com.example; import java.util.function.Supplier; public class SupplierEx1 { public static void main(String[] args) { beforeJava8(); fromJava8(); } private static void beforeJava8() { double pi = getPiValue(); System.out.println("Pi value is : " + pi); } private static double getPiValue() { double pi = 3.14; return pi; } private static void fromJava8() { double pi = 3.14; Supplier<double> supplier = () -> pi; System.out.println("Pi value is : " + supplier.get()); } }

Consumer Interface

Supplier in tam tersine tek bir input alir ve hic bir output dondurmez.

package com.example; package com.example; import java.util.function.Consumer; public class ConsumerEx1 { public static void main(String[] args) { beforeJava8(); fromJava8(); } private static void beforeJava8() { showUpperCase("Java8"); } private static void showUpperCase(String string) { System.out.println(string.toUpperCase()); } private static void fromJava8() { Consumer<string> consumer = msg -> System.out.println(msg.toUpperCase()); consumer.accept("Java8"); } }

ForEach 

package com.example; import java.util.Arrays; import java.util.List; public class ForEachExample { public static void main(String[] args) { beforeJava8(); fromJava8(); } private static void beforeJava8() { System.out.println("Before Java8"); List<integer> intList = Arrays.asList(1,2,3,4,5,6,7,8,9); for(int i: intList) { System.out.println(i); } } private static void fromJava8() { System.out.println("From Java8"); List<integer> intList = Arrays.asList(1,2,3,4,5,6,7,8,9); intList.forEach(System.out::println); } }


Default Interface

Java da interface genel bir taslaktir. Methodlar sadece tanimlanir. Icerikleri ise interface leri implemente eden siniflarda kodlanir. Ama interface lerin soyle bir dezavantaji var ; Interface de tanimlanan tum methodlar implemente edilmek zorunda yoksa compilation hatasi verir. Simdi soyle bir case dusunelim. Diyelim ki ilerde interface e yeni bir method eklememiz gerekiyor. Bu durumda diger tum classlar bu methodu implemente etmek zorunda yoksa compile time hatasi alir. Bu hem cok uzun olur hem de stakeholder lar tarafinda kabul edilmeyebilir. Bu durumda Java 8 ile gelen yeni bir ozellik olan default kullanabiliriz. Interface deki methodun basina default yazarak methodun default calismasini interface icersinde kodlariz. Bu sekilde bir implementasyonu oldugu icin diger class larda implemente edilmese de sorun yaratmaz, isteyen de implemente edebilir.

Static Method

Interface lerde static methodlar tanimlanabilir. Bu methodlarin icerigi interface de tanimlanmak zorundadir. Ve onu cagiran classlarda static methodlar override edilemez. Icerigi degistirelemez cunku compile hatasi verir. Static methodlar icinden non-static methodlara erisilemez. Interface de yer alan static methodlara erismek icin obje olusturmaya gerek yoktur, interfaceAdi.methodAdi seklinde erisilir.