Lambda Function Example

Author: shimanshu sharma

.idea/.gitignore

@@ -0,0 +1,30 @@
+package com.bootrcamp.demo;
+
+public class AnonymousInnerClassVsLambdas {
+    int number = 21;
+
+    void display() {
+        Operation operation1 = new Operation() {
+            int number = 41;
+            @Override
+            public void perform(int a, int b) {
+                System.out.println(this.number + a + b);
+            }
+        };
+
+        operation1.perform(1, 2);
+
+        Operation operation2 = (a, b) -> {
+            System.out.println(this.number + a + b);
+        };
+
+        operation2.perform(1,2);
+
+    }
+
+
+    public static void main(String[] args) {
+        new AnonymousInnerClassVsLambdas().display();
+    }
+
+}

.idea/misc.xml

@@ -0,0 +1,19 @@
+package com.bootrcamp.demo;
+
+
+interface EmployeeFI {
+
+    Employee createEmployee(Integer id, Integer age, String name);
+}
+
+public class ConstructorReferenceDemo {
+
+    public static void main(String[] args) {
+
+        EmployeeFI employeeFI = Employee::new;
+        Employee employee = employeeFI.createEmployee(1, 32, "Peter Parker");
+        System.out.println(employee);
+
+
+    }
+}

.idea/modules.xml

@@ -0,0 +1,33 @@
+package com.bootrcamp.demo;
+
+interface MyInterface1 {
+    default void display() {
+        System.out.println("MyInterface1");
+    }
+}
+
+interface MyInterface2 {
+    default void display() {
+        System.out.println("MyInterface2");
+    }
+}
+
+interface MyInterface3 extends MyInterface1, MyInterface2 {
+    default void display() {
+        MyInterface1.super.display();
+        MyInterface2.super.display();
+        System.out.println("MyInterface3");
+    }
+}
+
+public class DefaultMethodsDemo implements MyInterface3 {
+    public void display() {
+        MyInterface3.super.display();
+        System.out.println("DefaultMethodsDemo");
+    }
+
+
+    public static void main(String[] args) {
+        new DefaultMethodsDemo().display();
+    }
+}

.idea/vcs.xml

@@ -0,0 +1,10 @@
+package com.bootrcamp.demo;
+
+public class EffectivelyFinalDemo {
+
+    public static void main(String[] args) throws InterruptedException {
+        final int value = 23;
+        new Thread(() -> System.out.println(value)).start();
+        Thread.sleep(1000L);
+    }
+}

AnonymousInnerClassVsLambdas.java

@@ -0,0 +1,23 @@
+package com.bootrcamp.demo;
+
+public class Employee {
+
+    Integer id;
+    Integer age;
+    String name;
+
+    public Employee(Integer id, Integer age, String name) {
+        this.id = id;
+        this.age = age;
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", age=" + age +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

ConstructorReferenceDemo.java

@@ -0,0 +1,24 @@
+package com.bootrcamp.demo;
+
+@FunctionalInterface
+interface Operation {
+    void perform(int a, int b);
+}
+
+public class FunctionalProgramming {
+
+    static void performOperation(int a, int b, Operation operation) {
+        operation.perform(a,b);
+    }
+
+    public static void main(String[] args) {
+
+        performOperation(1, 2,(int a, int b)-> {System.out.println(a+b);});
+        performOperation(1, 2,(int a, int b)-> {System.out.println(a-b);});
+        performOperation(1, 2,(int a, int b)-> {System.out.println(a*2+b*2);});
+
+    }
+
+}
+
+

DefaultMethodsDemo.java

@@ -0,0 +1,18 @@
+package com.bootrcamp.demo;
+
+interface MyFunctionalInterface{
+
+    int returnValue(int number);
+}
+
+
+public class GoodiesWithLambdas {
+
+    public static void main(String[] args) {
+
+        MyFunctionalInterface myFunctionalInterface =  number -> number*number;
+
+        System.out.println(myFunctionalInterface.returnValue(5));;
+
+    }
+}

EffectivelyFinalDemo.java

@@ -0,0 +1,19 @@
+package com.bootrcamp.demo;
+
+import java.util.function.*;
+
+public class JDKDefinedFunctionalInterfaces {
+
+    public static void main(String[] args) {
+        Consumer<String> consumer = a -> System.out.println(a);
+        consumer.accept("54");
+        Predicate<Integer> isEven = a -> a % 2 == 0;
+        System.out.println(isEven.test(9));
+        Supplier<Integer> supplier = () -> 9;
+        System.out.println(supplier.get());
+        Function<Integer, Integer> getSquare = a -> a * a;
+        System.out.println(getSquare.apply(5));
+        BiFunction<Integer,Integer,Integer> multiply = (a,b)->a*b;
+        System.out.println(multiply.apply(2,3));;
+    }
+}

Employee.java

@@ -0,0 +1,26 @@
+package com.bootrcamp.demo;
+
+public class JDKFunctionalInterfaceDemo {
+
+    static void someStaticMethod( int i){
+        System.out.println("Hello from JDKFunctionalInterfaceDemo static method::"+i);
+    }
+
+     void someNonStaticMethod(int i){
+        System.out.println("Hello from JDKFunctionalInterfaceDemo non static method::"+i);
+    }
+
+
+
+    public static void main(String[] args) throws InterruptedException {
+
+
+        new Thread(() -> {
+            System.out.println("Another Thread ::::"+Thread.currentThread().getId());
+        }).start();
+
+        System.out.println("Main Thread ::::"+Thread.currentThread().getId());
+
+
+    }
+}

FunctionalProgramming.java

@@ -0,0 +1,13 @@
+package com.bootrcamp.demo;
+
+
+public class LambdasDemo {
+    public static void main(String[] args) {
+
+        Operation operation =(int a, int b)-> {
+                System.out.println(a+b);
+        };
+
+        operation.perform(1,2);
+    }
+}

GoodiesWithLambdas.java

@@ -0,0 +1,18 @@
+package com.bootrcamp.demo;
+
+interface MyReferenceInterface{
+    void display(int a);
+}
+
+public class MethodReferenceDemo {
+    public static void main(String[] args) {
+        MyReferenceInterface myReferenceInterface = (i)-> System.out.println(i);
+        myReferenceInterface.display(5);
+        myReferenceInterface = JDKFunctionalInterfaceDemo::someStaticMethod;
+        myReferenceInterface.display(2);
+        myReferenceInterface = new JDKFunctionalInterfaceDemo()::someNonStaticMethod;
+        myReferenceInterface.display(1);
+
+        MethodReferenceDemo methodReferenceDemo = new MethodReferenceDemo();
+    }
+}

JDKDefinedFunctionalInterfaces.java

@@ -0,0 +1,25 @@
+package com.bootrcamp.demo;
+
+import java.util.Arrays;
+
+public class OptionalDemo {
+
+    public static void main(String[] args) {
+
+        System.out.println(Arrays.asList(35,87)
+                .stream()
+                .filter(e->e%2==0)
+                .findFirst().orElse(-1));
+
+
+        System.out.println(Arrays.asList(35,87)
+                .stream()
+                .filter(e->e%2==0)
+                .findFirst().orElseGet(()->{
+                    ///Configuration environment
+                    return -234;
+                }));
+    }
+
+
+}

JDKFunctionalInterfaceDemo.java

@@ -0,0 +1,37 @@
+package com.bootrcamp.demo;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class ParallelStreamVsNormalStream {
+
+    public static void main(String[] args) {
+
+        long startTime = System.currentTimeMillis();
+        IntStream
+                .rangeClosed(1,10)
+                .parallel()
+                .filter(e->{
+                    try {
+                        Thread.sleep(1000l);
+                    } catch (InterruptedException ex) {
+                        ex.printStackTrace();
+                    }
+                    return e%2==0;} )
+                .map(e->{ try {
+                    Thread.sleep(1000l);
+                } catch (InterruptedException ex) {
+                    ex.printStackTrace();
+                }
+                return e*34;})
+                .boxed()
+                .collect(Collectors.toList());
+        long endTime = System.currentTimeMillis();
+
+        System.out.println(endTime-startTime);
+
+
+
+
+    }
+}

LambdasDemo.java

@@ -0,0 +1,22 @@
+package com.bootrcamp.demo;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+public class ParallelStreamsDemo {
+
+    public static void main(String[] args) {
+
+        IntStream.rangeClosed(0,50)
+                .parallel()
+                .forEach(System.out::println);
+
+        System.out.println("--------------");
+
+        Arrays.asList(1,2,3,4,5,6,7,8,9,10)
+                .parallelStream()
+                .forEach(System.out::println);
+
+
+    }
+}