├── .gitignore ├── README └── src └── code ├── comparator ├── Comparator_Example.java └── Comparator_Example1.java ├── generics ├── Generics_Example.java ├── Generics_Example1.java ├── Generics_Example2.java ├── Generics_Example3.java ├── Generics_Example4.java ├── Generics_Example5.java ├── Generics_Example6.java ├── Generics_Lowerbound_Wildcards.java ├── Generics_Unbound_Wildcard2.java ├── Generics_Upperbound_Wildcard.java └── Generics_Upperbound_Wildcard1.java ├── lambda ├── BiFunction_Example.java ├── BiFunction_Example2.java ├── ConstructorReference.java ├── Consumer_Example.java ├── Lambda.java ├── Lambda1.java ├── LambdaWithCollection.java ├── Local_Variable_Capture.java ├── MethodReference.java ├── MethodReference2.java ├── MethodReference3.java ├── MethodReference4.java ├── Predicate_Example.java └── Supplier_Example.java ├── optional ├── Basic.java ├── Optional_Array.java └── Optional_Property.java └── stream ├── Stream_Example.java ├── Stream_Example1.java ├── Stream_Example2.java ├── Stream_Example3.java ├── Stream_Example4.java ├── Stream_Example5.java ├── Stream_Example7.java ├── Stream_Example8.java ├── Stream_Example9.java ├── Stream_Filter.java ├── Stream_MapMethod.java └── Stream_Max_Min.java /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | out 3 | Java_Functional_Programming.iml -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | Java_Functional_Programming 2 | 3 | 4 | java functional programming best practices ---> 5 | 6 | Comparator: 7 | 1. Comparator example 8 | 9 | Generics: 10 | 1.Generics_Example 11 | 2.Generics_Lowerbound_Wildcards 12 | 3.Generics_Unbound_Wildcard 13 | 4.Generics_Upperbound_Wildcard 14 | 5.Generics_Upperbound_Wildcard 15 | 16 | Lambda: 17 | 1.BiFunction_Example 18 | 2.ConstructorReference 19 | 3.Consumer_Example 20 | 4.Lambda 21 | 5.LambdaWithCollection 22 | 6.Local_Variable_Capture 23 | 7.MethodReference 24 | 8.Predicate_Example 25 | 9.Supplier_Example.java 26 | 27 | Optional: 28 | 1.Basic 29 | 2.Optional_Array 30 | 3.Optional_Property 31 | 32 | Stream: 33 | 1.Stream_Example 34 | 2.Stream_Filter 35 | 3.Stream_MapMethod 36 | 4.Stream_Max_Min 37 | -------------------------------------------------------------------------------- /src/code/comparator/Comparator_Example.java: -------------------------------------------------------------------------------- 1 | package code.comparator; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.Comparator; 6 | import java.util.List; 7 | 8 | public class Comparator_Example { 9 | public static void main(String[] args) { 10 | List list=Student.getStudent(); 11 | Comparator comparator=Comparator.comparing(Student::getAge).reversed().thenComparing(Student::getName); 12 | Collections.sort(list,comparator); 13 | list.stream().forEach(System.out::println); 14 | } 15 | } 16 | 17 | class Student{ 18 | private int age; 19 | private String name; 20 | 21 | public Student(int age, String name) { 22 | this.age = age; 23 | this.name = name; 24 | } 25 | 26 | public int getAge() { 27 | return age; 28 | } 29 | 30 | public void setAge(int age) { 31 | this.age = age; 32 | } 33 | 34 | public String getName() { 35 | return name; 36 | } 37 | 38 | public void setName(String name) { 39 | this.name = name; 40 | } 41 | 42 | @Override 43 | public String toString() { 44 | return "Student{" + 45 | "age=" + age + 46 | ", name='" + name + '\'' + 47 | '}'; 48 | } 49 | 50 | public static List getStudent(){ 51 | return Arrays.asList( 52 | new Student(12,"sagar"), 53 | new Student(14,"navin"), 54 | new Student(22,"m_arafat"), 55 | new Student(22,"nadim") 56 | ); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/code/comparator/Comparator_Example1.java: -------------------------------------------------------------------------------- 1 | package code.comparator; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.Comparator; 6 | import java.util.List; 7 | 8 | public class Comparator_Example1 { 9 | public static void main(String[] args) { 10 | List list=Teacher.getList(); 11 | List list1=Teacher.getList(); 12 | List list2=Teacher.getList(); 13 | 14 | Comparator comparator= 15 | Comparator.comparing(Teacher::getAge).reversed() 16 | .thenComparing(Teacher::getName,Comparator.nullsFirst(String::compareTo)); 17 | Collections.sort(list,comparator); 18 | list.stream().forEach(System.out::println); 19 | 20 | Comparator comparator1= 21 | Comparator.comparing(Teacher::getName,Comparator.nullsLast(String::compareTo)); 22 | System.out.println(); 23 | Collections.sort(list1,comparator1); 24 | list1.stream().forEach(System.out::println); 25 | 26 | Comparator comparator2= 27 | Comparator.comparing(Teacher::getName,Comparator.nullsFirst(String::compareTo)); 28 | Collections.sort(list2,comparator2); 29 | System.out.println(""); 30 | list2.forEach(System.out::println); 31 | } 32 | } 33 | 34 | class Teacher{ 35 | private int age; 36 | private String name; 37 | 38 | public Teacher(int age, String name) { 39 | this.age = age; 40 | this.name = name; 41 | } 42 | 43 | public int getAge() { 44 | return age; 45 | } 46 | 47 | public void setAge(int age) { 48 | this.age = age; 49 | } 50 | 51 | public String getName() { 52 | return name; 53 | } 54 | 55 | public void setName(String name) { 56 | this.name = name; 57 | } 58 | 59 | @Override 60 | public String toString() { 61 | return "Teacher{" + 62 | "age=" + age + 63 | ", name='" + name + '\'' + 64 | '}'; 65 | } 66 | 67 | public static List getList(){ 68 | return Arrays.asList( 69 | new Teacher(44,"atik"), 70 | new Teacher(33,null), 71 | new Teacher(33,"mina"), 72 | new Teacher(45,"rajib"), 73 | new Teacher(49,"tarik"), 74 | new Teacher(55,"rahim") 75 | ); 76 | } 77 | } -------------------------------------------------------------------------------- /src/code/generics/Generics_Example.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | import java.util.stream.Collectors; 7 | 8 | public class Generics_Example { 9 | public static void main(String[] args) { 10 | List list1=Book.getBookList(); 11 | 12 | List list=new ArrayList<>(); 13 | list=list1.stream().map(i->i.getName()).collect(Collectors.toList()); 14 | 15 | list.forEach(System.out::println); 16 | } 17 | } 18 | 19 | class Book{ 20 | private String name; 21 | private Integer price; 22 | 23 | public Book(String name, Integer price) { 24 | this.name = name; 25 | this.price = price; 26 | } 27 | 28 | public String getName() { 29 | return name; 30 | } 31 | 32 | public void setName(String name) { 33 | this.name = name; 34 | } 35 | 36 | public Integer getPrice() { 37 | return price; 38 | } 39 | 40 | public void setPrice(Integer price) { 41 | this.price = price; 42 | } 43 | 44 | @Override 45 | public String toString() { 46 | return "Book{" + 47 | "name='" + name + '\'' + 48 | ", price=" + price + 49 | '}'; 50 | } 51 | 52 | public static List getBookList(){ 53 | return Arrays.asList( 54 | new Book("a",23), 55 | new Book("b",44), 56 | new Book("c",55), 57 | new Book("d",22), 58 | new Book("e",11) 59 | ); 60 | } 61 | } -------------------------------------------------------------------------------- /src/code/generics/Generics_Example1.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | class Print_Array{ 6 | void printArray(T[] arr){ 7 | for(T x:arr){ 8 | System.out.println(x); 9 | } 10 | } 11 | } 12 | public class Generics_Example1 { 13 | public static void main( String args[] ) { 14 | Print_Array print_Array = new Print_Array(); 15 | Integer[] intArray = { 1, 2, 3 }; 16 | String[] stringArray = {"Hello", "World"}; 17 | print_Array.printArray(intArray); 18 | print_Array.printArray(stringArray); 19 | int count = 0; 20 | 21 | for (Method method : Print_Array.class.getDeclaredMethods()) { 22 | String name = method.getName(); 23 | 24 | if(name.equals("printArray")) 25 | count++; 26 | } 27 | 28 | if(count > 1)System.out.println("Method overloading is not allowed!"); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Example2.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | class PrintArray { 4 | void printArray(T[] arr){ 5 | for(T x:arr){ 6 | System.out.println(x); 7 | } 8 | } 9 | } 10 | 11 | public class Generics_Example2 { 12 | public static void main(String[] args) { 13 | PrintArray printArray=new PrintArray(); 14 | Integer[] intArray = { 1, 2, 3 }; 15 | String[] stringArray = {"Hello", "World"}; 16 | 17 | printArray.printArray(intArray); 18 | printArray.printArray(stringArray); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Example3.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | public class Generics_Example3 { 4 | T obj1; 5 | U obj2; 6 | 7 | public Generics_Example3(T obj1, U obj2) { 8 | this.obj1 = obj1; 9 | this.obj2 = obj2; 10 | } 11 | 12 | void printObj(){ 13 | System.out.println(obj1); 14 | System.out.println(obj2); 15 | } 16 | } 17 | class ObjCreator{ 18 | public static void main(String[] args) { 19 | Generics_Example3 generics_example3=new Generics_Example3<>("sagar",24); 20 | generics_example3.printObj(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Example4.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | public class Generics_Example4 { 4 | public static void genericPrint(T value){ 5 | System.out.println(value.getClass().getName()+" "+value); 6 | } 7 | 8 | public static void main(String[] args) { 9 | genericPrint(234); 10 | genericPrint("sagar"); 11 | genericPrint(3.4); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Example5.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | class Employee { 4 | void printEmployee(String[] s){ 5 | for(String x:s){ 6 | System.out.println(x); 7 | } 8 | } 9 | } 10 | 11 | public class Generics_Example5 { 12 | public static void main(String[] args) { 13 | String[] list=new String[4]; 14 | list[0]="sagar"; 15 | list[1]="sourab"; 16 | list[2]="navin"; 17 | list[3]="nahid"; 18 | 19 | Employee ep=new Employee(); 20 | ep.printEmployee(list); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Example6.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Generics_Example6 { 6 | public static void printArray(E[] arr){ 7 | Arrays.stream(arr).forEach(i->System.out.print(i+" ")); 8 | } 9 | public static void main(String[] args) { 10 | Integer arr[]={0, 20, 30, 40, 50}; 11 | Character[] charArray = { 'J', 'A', 'V', 'A' }; 12 | 13 | printArray(arr); 14 | System.out.println(); 15 | printArray(charArray); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Lowerbound_Wildcards.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Generics_Lowerbound_Wildcards { 7 | public static void printData(List data ){ 8 | data.stream().forEach(i-> System.out.print(i+" ")); 9 | } 10 | 11 | public static void main(String[] args) { 12 | printData(list); 13 | System.out.println(); 14 | printData(list1); 15 | } 16 | 17 | static List list= Arrays.asList(1,2,3,4,5); 18 | static List list1=Arrays.asList(1.1,2.3,2.1,22); 19 | } 20 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Unbound_Wildcard2.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Generics_Unbound_Wildcard2 { 7 | public static void printData(List data){ 8 | data.stream().forEach(i-> System.out.print(i+" ")); 9 | } 10 | 11 | public static void main(String[] args) { 12 | printData(list); 13 | } 14 | 15 | static List list= Arrays.asList("sagar","a","b","c"); 16 | } 17 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Upperbound_Wildcard.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Generics_Upperbound_Wildcard { 7 | public static void printShape(List shape){ 8 | shape.stream().forEach(shape1 -> shape1.draw()); 9 | } 10 | public static void main(String[] args) { 11 | List list= Arrays.asList( 12 | new Rectangle(), 13 | new Circle(), 14 | new Rectangle() 15 | ); 16 | printShape(list); 17 | } 18 | } 19 | 20 | interface Shape{ 21 | void draw(); 22 | } 23 | 24 | class Rectangle implements Shape{ 25 | 26 | @Override 27 | public void draw() { 28 | System.out.println("Implemented rectangle"); 29 | } 30 | } 31 | 32 | class Circle implements Shape{ 33 | 34 | @Override 35 | public void draw() { 36 | System.out.println("Implemented circle"); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/code/generics/Generics_Upperbound_Wildcard1.java: -------------------------------------------------------------------------------- 1 | package code.generics; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Generics_Upperbound_Wildcard1 { 7 | public static void printData(List data){ 8 | data.stream().forEach(i-> System.out.print(i+" ")); 9 | } 10 | 11 | static List list= Arrays.asList(1,2,3,4,5); 12 | static List list1=Arrays.asList(1.2,3.2,3.4,5.3); 13 | 14 | public static void main(String[] args) { 15 | printData(list); 16 | System.out.println(); 17 | printData(list1); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/code/lambda/BiFunction_Example.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | import java.util.function.BiFunction; 4 | import java.util.function.ToLongBiFunction; 5 | 6 | public class BiFunction_Example { 7 | public static void main(String[] args) { 8 | BiFunction biFunction=(a,b)->a+b; 9 | System.out.println(biFunction.apply(2,2)); 10 | 11 | BiFunction biFunction2=(string1,string2)->string1+string2; 12 | System.out.println(biFunction2.apply("naimul ","sagar")); 13 | 14 | ToLongBiFunction toLongBiFunction=(x,y)->x+y; 15 | System.out.println(toLongBiFunction.applyAsLong(22,22)); 16 | 17 | BiFunction biFunction1=new BiFunction() { 18 | @Override 19 | public Integer apply(Integer integer, Integer integer2) { 20 | return integer*integer2; 21 | } 22 | }; 23 | System.out.println(biFunction1.apply(3,3)); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/code/lambda/BiFunction_Example2.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | import java.util.function.BiFunction; 4 | 5 | public class BiFunction_Example2 { 6 | public static void main(String[] args) { 7 | BiFunction biFunction=(a,b)->a+b; 8 | biFunction=biFunction.andThen(x->x*2); 9 | System.out.println(biFunction.apply(2,2)); 10 | 11 | BiFunction biFunction1=(s1,s2)->s1+s2; 12 | biFunction1=biFunction1.andThen(value->value+"add something"); 13 | System.out.println(biFunction1.apply("sagar"," do ")); 14 | 15 | BiFunction biFunction2=new BiFunction() { 16 | @Override 17 | public Integer apply(Integer integer, Integer integer2) { 18 | return integer+integer2; 19 | } 20 | }.andThen(v->v*2); 21 | System.out.println(biFunction2.apply(5,5)); 22 | 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/code/lambda/ConstructorReference.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | interface ConstructorRef{ 5 | Payment isPaid(String payment_status); 6 | } 7 | 8 | class Payment{ 9 | Payment(String payment_status){ 10 | System.out.println(payment_status); 11 | } 12 | } 13 | 14 | public class ConstructorReference { 15 | public static void main(String[] args) { 16 | ConstructorRef constructorRef= Payment::new; 17 | constructorRef.isPaid("Done"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/code/lambda/Consumer_Example.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.function.Consumer; 6 | import java.util.stream.Collector; 7 | import java.util.stream.Collectors; 8 | 9 | public class Consumer_Example { 10 | public static void main(String[] args) { 11 | Consumer consumer1=s-> System.out.println(s); 12 | consumer1.accept(2*2); 13 | 14 | Consumer consumer2=s-> System.out.println(s+" added extra"); 15 | consumer2.accept("text"); 16 | 17 | List list= Arrays.asList(4,3,2,1); 18 | Consumer> listConsumer=s->s.stream().map(x->x*3).forEach(System.out::println); 19 | listConsumer.accept(list); 20 | 21 | List list2= Arrays.asList(44,33,22,11); 22 | List> mergeList=Arrays.asList(list,list2); 23 | Consumer>> listConsumer1= 24 | s->s.stream().flatMap(x->x.stream()).map(d->d*4).sorted().forEach(System.out::println); 25 | listConsumer1.accept(mergeList); 26 | 27 | Consumer consumer=new Consumer() { 28 | @Override 29 | public void accept(Integer integer) { 30 | System.out.println(integer); 31 | } 32 | }; 33 | consumer.accept(8); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/code/lambda/Lambda.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | interface Draw { 4 | void draw(); 5 | } 6 | 7 | // problem without lambda 8 | public class Lambda { 9 | public static void main(String[] args) { 10 | Draw draw = new Draw() { 11 | public void draw() { 12 | System.out.println("Draw a picture"); 13 | } 14 | }; 15 | draw.draw(); 16 | } 17 | } 18 | 19 | // solution with lambda 20 | class Solution { 21 | 22 | public static void main(String[] args) { 23 | Draw draw = () -> System.out.println("Draw another picture"); 24 | draw.draw(); 25 | 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/code/lambda/Lambda1.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | interface DrawSomething { 4 | 5 | void drawPicture(int x, int y); 6 | } 7 | 8 | public class Lambda1 { 9 | 10 | static DrawSomething drawSomething = (x, y) -> System.out.println(x + y); 11 | 12 | static DrawSomething drawSomething1 = (a, b) -> System.out.println(a + b); 13 | 14 | public static void main(String[] args) { 15 | int x = 2, y = 4; 16 | drawSomething.drawPicture(x, y); 17 | drawSomething1.drawPicture(y, y); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/code/lambda/LambdaWithCollection.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | public class LambdaWithCollection { 8 | public static void main(String[] args) { 9 | List list=new ArrayList(); 10 | list.add(1); 11 | list.add(2); 12 | list.add(3); 13 | list.add(4); 14 | 15 | List list1=new ArrayList(); 16 | list1.add("sagar"); 17 | list1.add("sourab"); 18 | list1.add("navin"); 19 | 20 | list1.forEach(word -> System.out.println(word.toUpperCase())); 21 | list.forEach((a)-> System.out.println(a)); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/code/lambda/Local_Variable_Capture.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | public class Local_Variable_Capture { 4 | public static void main(String[] args) { 5 | var word="sagar"; 6 | var num=23; 7 | 8 | Example example=(x)->{ System.out.println(x.length()); }; 9 | example.printSomething(word); 10 | 11 | Example1 example1=(x)-> x.toUpperCase(); 12 | System.out.println(example1.printSomething(word)); 13 | 14 | Example2 example2=(x)-> x*2; 15 | System.out.println(example2.printSomething(num)); 16 | } 17 | } 18 | 19 | interface Example{ 20 | void printSomething(String value); 21 | } 22 | 23 | interface Example1{ 24 | String printSomething(String value); 25 | } 26 | 27 | interface Example2{ 28 | Integer printSomething(Integer value); 29 | } -------------------------------------------------------------------------------- /src/code/lambda/MethodReference.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | interface Vehicle{ 5 | void car(); 6 | } 7 | 8 | public class MethodReference { 9 | public static void property(){ 10 | System.out.println("I have a car"); 11 | } 12 | 13 | static Vehicle vehicle= MethodReference::property; 14 | 15 | public static void main(String[] args) { 16 | vehicle.car(); 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /src/code/lambda/MethodReference2.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | import java.util.function.BiFunction; 5 | 6 | public class MethodReference2 { 7 | public static int mul(int a,int b){ 8 | return (a-b); 9 | } 10 | 11 | public static float add(float a,float b){ 12 | return (a+b); 13 | } 14 | 15 | public static double add(double a,double b){ 16 | return (a+b); 17 | } 18 | 19 | public static String add(String a,String b){ 20 | return (a+b); 21 | } 22 | } 23 | 24 | class MethodReferenceExample{ 25 | public static void main(String[] args) { 26 | BiFunction one= MethodReference2::mul; 27 | BiFunction two= MethodReference2::add; 28 | BiFunction three= MethodReference2::add; 29 | BiFunction four= MethodReference2::add; 30 | 31 | System.out.println(one.apply(3,3)); 32 | System.out.println(two.apply(2.2f, 4.2f)); 33 | System.out.println(three.apply(2.6, 6.6)); 34 | System.out.println(four.apply("sagar", "sourab")); 35 | 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/code/lambda/MethodReference3.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | interface Reference{ 5 | public String referMe(); 6 | } 7 | 8 | public class MethodReference3 { 9 | String refer(){ 10 | return ("i am refering a method "); 11 | } 12 | } 13 | 14 | class MethodReferenceTry { 15 | public static void main(String[] args) { 16 | MethodReference3 methodReference3=new MethodReference3(); 17 | 18 | Reference reference= methodReference3::refer; 19 | Reference reference1= new MethodReference3()::refer; 20 | 21 | System.out.println(reference.referMe()); 22 | System.out.println(reference1.referMe()); 23 | } 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /src/code/lambda/MethodReference4.java: -------------------------------------------------------------------------------- 1 | 2 | package code.lambda; 3 | 4 | import java.util.Arrays; 5 | import java.util.List; 6 | 7 | public class MethodReference4 { 8 | public static void main(String[] args) { 9 | List list=Arrays.asList(1,2,3,4,56,7,8,9,12,33,44,55,667,77,88,99); 10 | 11 | list.forEach(i -> doubleValue(i)); 12 | } 13 | public static void doubleValue(int i){ 14 | System.out.println(i*2); 15 | } 16 | } 17 | 18 | class Method_Reference4 { 19 | public static void main(String[] args) { 20 | List list=Arrays.asList(1,2,3,4,56,7,8,9,12,33,44,55,667,77,88,99); 21 | 22 | list.forEach( Method_Reference4::doubleValue); 23 | } 24 | public static void doubleValue(int i){ 25 | System.out.println(i*2); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/code/lambda/Predicate_Example.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | import java.awt.color.ProfileDataException; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | import java.util.function.Predicate; 7 | 8 | public class Predicate_Example { 9 | public static void main(String[] args) { 10 | Predicate predicate1=(s)->s.startsWith("s"); 11 | System.out.println(predicate1.test("sagarsagarsagar")); 12 | 13 | List list= Arrays.asList(1,2,3,4,5); 14 | Predicate> predicate2=l->l.contains(1); 15 | System.out.println(predicate2.and(x->x.size()>3).test(list)); 16 | 17 | Predicate predicate=new Predicate() { 18 | @Override 19 | public boolean test(Integer integer) { 20 | return integer%2==0; 21 | } 22 | }.and(s->s<4); 23 | System.out.println(predicate.test(3)); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/code/lambda/Supplier_Example.java: -------------------------------------------------------------------------------- 1 | package code.lambda; 2 | 3 | import java.util.function.Supplier; 4 | 5 | public class Supplier_Example { 6 | public static void main(String[] args) { 7 | Supplier doubleSupplier=()->Math.random(); 8 | System.out.println(doubleSupplier.get()); 9 | 10 | Supplier integerSupplier=()-> 3; 11 | System.out.println(integerSupplier.get()); 12 | 13 | Supplier supplier=new Supplier() { 14 | @Override 15 | public Double get() { 16 | return Math.random(); 17 | } 18 | }; 19 | System.out.println(supplier.get()); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/code/optional/Basic.java: -------------------------------------------------------------------------------- 1 | package code.optional; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Optional; 6 | 7 | public class Basic { 8 | public static void main(String[] args) { 9 | // returns an empty instance 10 | Optional optionalS=Optional.empty(); 11 | System.out.println(optionalS); 12 | 13 | // of() throw nullPointerException because of null values orElse it works 14 | Optional optional=Optional.of("Hello"); 15 | // Optional optional=Optional.of(null); 16 | System.out.println(optional); 17 | 18 | // ofNullable() takes value and print value , if null it prints empty 19 | Optional optional1=Optional.ofNullable("Hi"); 20 | System.out.println(optional1); 21 | 22 | Optional optional2=Optional.ofNullable(null); 23 | //orElse print it's value instead of null value provided 24 | System.out.println(optional2.orElse("Null value provided")); 25 | 26 | Optional optional4=Optional.ofNullable(null); 27 | System.out.println(optional4.map(String::toUpperCase).orElse("No String provided or Null value")); 28 | System.out.println(optional4.map(String::toUpperCase).orElseGet(()-> {return "Null provide";})); 29 | 30 | Optional optional3=Optional.ofNullable("sagar"); 31 | System.out.println(optional3.map(String::toUpperCase).orElse("No String provided or Null value")); 32 | optional3.ifPresent(s-> System.out.println(optional3)); 33 | optional3.ifPresent(value-> System.out.println("Value is present")); 34 | optional3.ifPresentOrElse(s-> System.out.println("value is "+optional3),()-> System.out.println("value is not present")); 35 | 36 | 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/code/optional/Optional_Array.java: -------------------------------------------------------------------------------- 1 | package code.optional; 2 | 3 | import java.util.Optional; 4 | 5 | public class Optional_Array { 6 | public static void main(String[] args) { 7 | String []arr=new String[5]; 8 | Optional value=Optional.ofNullable(arr[2]); 9 | System.out.println(value); 10 | value.ifPresent(s-> System.out.println(s)); 11 | value.ifPresentOrElse(s-> System.out.println(s.toUpperCase()),()-> System.out.println("NO value provided")); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/code/optional/Optional_Property.java: -------------------------------------------------------------------------------- 1 | package code.optional; 2 | 3 | import org.w3c.dom.ls.LSOutput; 4 | 5 | import java.util.Optional; 6 | 7 | public class Optional_Property { 8 | public static void main(String[] args) { 9 | Person person=new Person("sagar","dhaka"); 10 | System.out.println(person.getAddress().map(String::toUpperCase).orElse("Address not found")); 11 | person.getName().ifPresent(s-> System.out.println("value is "+s)); 12 | person.getName().ifPresent(System.out::println); 13 | person.getName() 14 | .ifPresentOrElse((s)-> System.out.println(s.toUpperCase()),()-> System.out.println("No value found")); 15 | 16 | System.out.println(person.getName().isPresent()); 17 | System.out.println(person.getName().isEmpty()); 18 | System.out.println(person.getAddress().get()); 19 | } 20 | } 21 | 22 | class Person{ 23 | private String name; 24 | private String address; 25 | 26 | public Person(String name, String address) { 27 | this.name = name; 28 | this.address = address; 29 | } 30 | 31 | public Optional getName() { 32 | return Optional.ofNullable(name); 33 | } 34 | 35 | public void setName(String name) { 36 | this.name = name; 37 | } 38 | 39 | public Optional getAddress() { 40 | return Optional.ofNullable(address); 41 | } 42 | 43 | public void setAddress(String address) { 44 | this.address = address; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.List; 6 | import java.util.Map; 7 | import java.util.stream.Collectors; 8 | 9 | public class Stream_Example { 10 | public static void main(String[] args) { 11 | List list= Student.getStudentList(); 12 | list.forEach(System.out::println); 13 | list.forEach(student -> System.out.println(student)); 14 | 15 | List male=list.stream() 16 | .filter(student -> student.getGender().equals(Gender.MALE)).collect(Collectors.toList()); 17 | List female=list.stream() 18 | .filter(student -> student.getGender().equals(Gender.FEMALE)).collect(Collectors.toList()); 19 | System.out.println(male); 20 | System.out.println(female); 21 | 22 | List age=list.stream().filter(student -> student.getAge()>12).collect(Collectors.toList()); 23 | System.out.println(age); 24 | 25 | List number=Arrays.asList(41,72,3,4); 26 | System.out.println(number.stream().sorted().collect(Collectors.toList())); 27 | 28 | List sortedList=list.stream() 29 | .sorted(Comparator.comparing(Student::getAge).reversed().thenComparing(Student::getName)) 30 | .collect(Collectors.toList()); 31 | sortedList.forEach(System.out::println); 32 | 33 | boolean allMatch=list.stream().allMatch(student -> student.getAge()>7); 34 | System.out.println(allMatch); 35 | 36 | boolean anyMatch=list.stream().anyMatch(student -> student.getAge()>33); 37 | System.out.println(anyMatch); 38 | 39 | boolean noMatch=list.stream().noneMatch(student -> student.getName().equals("sagar")); 40 | System.out.println(noMatch); 41 | 42 | list.stream().max(Comparator.comparing(Student::getAge)) 43 | .ifPresentOrElse(System.out::println,()-> System.out.println("not found")); 44 | list.stream().min(Comparator.comparing(Student::getAge)) 45 | .ifPresentOrElse(System.out::println,()-> System.out.println("not found")); 46 | 47 | Map> group=list.stream().collect(Collectors.groupingBy(Student::getGender)); 48 | group.forEach((gender,students)->{ 49 | System.out.println(gender); 50 | students.forEach(System.out::println); 51 | }); 52 | 53 | list.stream().filter(student -> student.getGender().equals(Gender.FEMALE)) 54 | .max(Comparator.comparing(Student::getAge)).map(Student::getName) 55 | .ifPresentOrElse(student-> System.out.println("youngest student "+student),()-> System.out.println("not found")); 56 | } 57 | } 58 | 59 | class Student{ 60 | private String name; 61 | private int age; 62 | private Gender gender; 63 | 64 | public Student(String name, int age, Gender gender) { 65 | this.name = name; 66 | this.age = age; 67 | this.gender = gender; 68 | } 69 | 70 | public String getName() { 71 | return name; 72 | } 73 | 74 | public void setName(String name) { 75 | this.name = name; 76 | } 77 | 78 | public int getAge() { 79 | return age; 80 | } 81 | 82 | public void setAge(int age) { 83 | this.age = age; 84 | } 85 | 86 | public Gender getGender() { 87 | return gender; 88 | } 89 | 90 | public void setGender(Gender gender) { 91 | this.gender = gender; 92 | } 93 | 94 | @Override 95 | public String toString() { 96 | return "Student{" + 97 | "name='" + name + '\'' + 98 | ", age=" + age + 99 | ", gender=" + gender + 100 | '}'; 101 | } 102 | 103 | public static List getStudentList(){ 104 | return Arrays.asList( 105 | new Student("sagar",15,Gender.MALE),new Student("navin",13,Gender.MALE), 106 | new Student("sumaiya",13,Gender.FEMALE),new Student("nitu",8,Gender.FEMALE) 107 | ); 108 | } 109 | } 110 | 111 | enum Gender{ 112 | MALE,FEMALE; 113 | } 114 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example1.java: -------------------------------------------------------------------------------- 1 | 2 | package code.stream; 3 | 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | import java.util.stream.Collectors; 7 | 8 | class School_Student { 9 | int id; 10 | String name; 11 | int age; 12 | 13 | public School_Student(int id, String name, int age){ 14 | this.id=id; 15 | this.name=name; 16 | this.age=age; 17 | } 18 | } 19 | public class Stream_Example1 { 20 | public static void main(String[] args) { 21 | List list=new ArrayList<>(); 22 | 23 | list.add(new School_Student(1,"sagar",22)); 24 | list.add(new School_Student(2,"sourab",12)); 25 | list.add(new School_Student(3,"naim",32)); 26 | list.add(new School_Student(4,"navin",2)); 27 | list.add(new School_Student(5,"nahid",12)); 28 | 29 | List list1=list.stream() 30 | .filter(a -> a.age>12) 31 | .map(a->a.name) 32 | .collect(Collectors.toList()); 33 | 34 | System.out.println(list1); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example2.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.List; 6 | import java.util.stream.Collectors; 7 | import java.util.stream.DoubleStream; 8 | import java.util.stream.Stream; 9 | 10 | public class Stream_Example2 { 11 | public static void main(String[] args) { 12 | List list= Arrays.asList(1,2,3,4,5); 13 | System.out.println(list.stream().filter(value->value%2==0).collect(Collectors.toList())); 14 | System.out.println(list.stream().filter(x->x%2==0).mapToInt(i->i).sum()); 15 | list.stream().flatMapToDouble(i-> DoubleStream.of(i*2)).map(j->j).forEach(System.out::println); 16 | 17 | List list1= Arrays.asList("sagar","sourab","navin","nahid"); 18 | list1.stream().filter(name->!name.equals("sagar")).forEach(System.out::println); 19 | 20 | Stream stream=Stream.of(1,2,3,4,5,6,7,8); 21 | List list2=stream.collect(Collectors.toList()); 22 | System.out.println(list2); 23 | 24 | Stream stream1=Stream.of(1,2,3,4,5,6,7,8); 25 | Integer[] arr=stream1.toArray(Integer[]::new); 26 | System.out.println(Arrays.toString(arr)); 27 | 28 | int[] s=new int[]{4,5,6,7}; 29 | System.out.println(Arrays.toString(s)); 30 | 31 | Stream stream2=Stream.of(22,33,445,66666,11,2,3,5); 32 | stream2.sorted().forEach(System.out::println); 33 | 34 | Stream stream3=Stream.of(22,33,445,66666,11,2,3,5); 35 | stream3.sorted(Comparator.reverseOrder()).forEach(System.out::println); 36 | } 37 | } 38 | 39 | 40 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example3.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Optional; 6 | 7 | public class Stream_Example3 { 8 | public static void main(String[] args) { 9 | List list=User.getUser(); 10 | Optional result=list.stream().map(user -> user.getAddress().stream()) 11 | .flatMap(stringStream -> stringStream.filter(address->address.equals("dhaka"))).findAny(); 12 | result.ifPresent(System.out::println); 13 | } 14 | 15 | static class User{ 16 | String name; 17 | List address; 18 | 19 | public User(String name, List address) { 20 | this.name = name; 21 | this.address = address; 22 | } 23 | 24 | public String getName() { 25 | return name; 26 | } 27 | 28 | public void setName(String name) { 29 | this.name = name; 30 | } 31 | 32 | public List getAddress() { 33 | return address; 34 | } 35 | 36 | public void setAddress(List address) { 37 | this.address = address; 38 | } 39 | 40 | @Override 41 | public String toString() { 42 | return "User{" + 43 | "name='" + name + '\'' + 44 | ", address=" + address + 45 | '}'; 46 | } 47 | 48 | static List getUser(){ 49 | return Arrays.asList( 50 | new User("sagar",Arrays.asList("dhaka","comilla")), 51 | new User("sourab",Arrays.asList("dhaka","khulna")), 52 | new User("nabin",Arrays.asList("dhaka","rajshahi")), 53 | new User("nahid",Arrays.asList("dhaka","sylhet")) 54 | ); 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example4.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Stream_Example4 { 7 | public static void main(String[] args) { 8 | List list=new ArrayList<>(); 9 | list.add(new Car1(1,44000)); 10 | list.add(new Car1(2,45000)); 11 | list.add(new Car1(3,46000)); 12 | list.add(new Car1(4,47000)); 13 | list.add(new Car1(5,48000)); 14 | list.add(new Car1(6,49000)); 15 | 16 | Car1 car=list.stream() 17 | .max((p1,p2) -> p1.price > p2.price ? 1: -1 ) 18 | .get(); 19 | 20 | Car1 car1=list.stream() 21 | .min((a,b)-> a.price< b.price ? -1:1 ) 22 | .get(); 23 | 24 | System.out.println("maximum price " +car.price); 25 | System.out.println("minimum price " +car1.price); 26 | } 27 | } 28 | 29 | class Car { 30 | int id; 31 | int price; 32 | 33 | Car(int id, int price) { 34 | this.id = id; 35 | this.price = price; 36 | } 37 | } -------------------------------------------------------------------------------- /src/code/stream/Stream_Example5.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | import java.util.stream.Stream; 7 | 8 | public class Stream_Example5 { 9 | public static void main(String[] args) { 10 | //map() example 11 | List list = Arrays.asList(31, 61, 91, 12, 15); 12 | list.stream().map(i->i*2).map(i->i*2).forEach(System.out::println); 13 | 14 | List list1 = Arrays.asList("sagar","sourab","navin","nahid"); 15 | list1.stream().map(s->s.toUpperCase()).map(s->s.startsWith("S")).forEach(System.out::println); 16 | 17 | List list2 = Arrays.asList("sagar","sourab","navin","nahid"); 18 | list2.stream().filter(s->s.length()>5).map(s->s.toUpperCase()).forEach(System.out::println); 19 | 20 | //flatMap() example 21 | List one=Arrays.asList(1,2,3); 22 | List two=Arrays.asList(4,5,6); 23 | List three=Arrays.asList(7,8,9); 24 | List> merge=Arrays.asList(one,two,three); 25 | merge.stream().map(s->s).forEach(System.out::println); 26 | merge.stream().flatMap(s->s.stream()).map(s->s*2).forEach(System.out::println); 27 | System.out.println(merge.stream().flatMap(s->s.stream()).map(s->s*3).collect(Collectors.toList())); 28 | 29 | List four=Arrays.asList("a","b","c"); 30 | List five=Arrays.asList("d","e","f"); 31 | List six=Arrays.asList("g","h","i"); 32 | List> merge1=Arrays.asList(four,five,six); 33 | merge1.stream().flatMap(s->s.stream()).forEach(System.out::println); 34 | System.out.println(merge1.stream().flatMap(s->s.stream()).map(s->s.toUpperCase()).collect(Collectors.toList())); 35 | 36 | List list3 = Arrays.asList("sagar","sourab","navin","nahid"); 37 | list3.stream().flatMap(s-> Stream.of(s.charAt(3))).map(s-> s.toString()).forEach(System.out::println); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example7.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Stream_Example7 { 7 | public static void main(String[] args) { 8 | List list= Arrays.asList("av","abc","bc","bcde","aa","dd","ddeecc"); 9 | System.out.println(list.stream().reduce((s1,s2)->s1.length()>s2.length()?s1:s2)); 10 | 11 | String []word={"naimul","haque","sagar"}; 12 | System.out.println(Arrays.stream(word).reduce((s1,s2)->s1+" "+s2)); 13 | 14 | List array = Arrays.asList( 4, 6, 8); 15 | System.out.println(array.stream().reduce(1,(s1,s2)->s1+s2)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example8.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | public class Stream_Example8 { 8 | public static void main(String[] args) { 9 | List list= Arrays.asList(10,20,30,40,50,60,70,80,90); 10 | 11 | int x=list.stream().map(i -> i) 12 | //.reduce(12,(i,j)-> i+j); 13 | //.reduce(12, (i,j) -> Integer.sum(i, j)); 14 | .reduce(12, Integer::sum); 15 | System.out.println(x); 16 | 17 | int z=list.stream() 18 | .collect(Collectors.summingInt(i -> i)); 19 | 20 | System.out.println(z); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Example9.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class Stream_Example9 { 7 | public static void main(String[] args) { 8 | List list= Arrays.asList(44,55,33,66,77,22); 9 | System.out.println(list.stream().filter(i->i%2==0).map(i->i*2).findFirst().orElse(0)); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Filter.java: -------------------------------------------------------------------------------- 1 | 2 | package code.stream; 3 | 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | import java.util.stream.Collectors; 7 | 8 | class Student1{ 9 | int id; 10 | String name; 11 | int age; 12 | 13 | public Student1(int id,String name,int age){ 14 | this.id=id; 15 | this.name=name; 16 | this.age=age; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "Student1{" + "id=" + id + ", name=" + name + ", age=" + age + '}'; 22 | } 23 | 24 | } 25 | 26 | public class Stream_Filter { 27 | public static void main(String[] args) { 28 | List list=new ArrayList<>(); 29 | 30 | list.add(new Student1(1,"sagar",22)); 31 | list.add(new Student1(2,"sourab",12)); 32 | list.add(new Student1(3,"naim",32)); 33 | list.add(new Student1(4,"navin",2)); 34 | list.add(new Student1(5,"nahid",12)); 35 | 36 | list.stream() 37 | .filter(i->i.age<22) 38 | .forEach(System.out::println); 39 | //.forEach((i)->System.out.println(i)); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/code/stream/Stream_MapMethod.java: -------------------------------------------------------------------------------- 1 | 2 | package code.stream; 3 | 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | class Student2{ 8 | int id; 9 | String name; 10 | int age; 11 | 12 | public Student2(int id,String name,int age){ 13 | this.id=id; 14 | this.name=name; 15 | this.age=age; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "Student1{" + "id=" + id + ", name=" + name + ", age=" + age + '}'; 21 | } 22 | 23 | } 24 | 25 | public class Stream_MapMethod { 26 | public static void main(String[] args) { 27 | List list=new ArrayList<>(); 28 | 29 | list.add(new Student2(1,"sagar",22)); 30 | list.add(new Student2(2,"sourab",12)); 31 | list.add(new Student2(3,"naim",32)); 32 | list.add(new Student2(4,"navin",2)); 33 | list.add(new Student2(5,"nahid",12)); 34 | 35 | list.stream() 36 | .map(i-> i.age*2) 37 | .forEach(System.out::println); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/code/stream/Stream_Max_Min.java: -------------------------------------------------------------------------------- 1 | package code.stream; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Stream_Max_Min { 7 | public static void main(String[] args) { 8 | List list=new ArrayList<>(); 9 | list.add(new Car1(1,44000)); 10 | list.add(new Car1(2,45000)); 11 | list.add(new Car1(3,46000)); 12 | list.add(new Car1(4,47000)); 13 | list.add(new Car1(5,48000)); 14 | list.add(new Car1(6,49000)); 15 | 16 | Car1 car=list.stream() 17 | .max((p1,p2) -> p1.price > p2.price ? 1: -1 ) 18 | .get(); 19 | 20 | Car1 car1=list.stream() 21 | .min((a,b)-> a.price< b.price ? -1:1 ) 22 | .get(); 23 | 24 | System.out.println("maximum price " +car.price); 25 | System.out.println("minimum price " +car1.price); 26 | } 27 | } 28 | 29 | class Car1 { 30 | int id; 31 | int price; 32 | 33 | Car1(int id, int price){ 34 | this.id=id; 35 | this.price=price; 36 | } 37 | } --------------------------------------------------------------------------------