{"id":4280,"date":"2021-05-15T09:14:52","date_gmt":"2021-05-15T09:14:52","guid":{"rendered":"https:\/\/codethataint.com\/blog\/?p=4280"},"modified":"2023-12-02T15:36:29","modified_gmt":"2023-12-02T15:36:29","slug":"how-lambda-expression-works-internally","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/how-lambda-expression-works-internally\/","title":{"rendered":"How Lambda Expression Works Internally"},"content":{"rendered":"

When to use Lambda Expressions<\/strong>
\nIf you have a functional Interface which has only one Abstract Method then we can use Lambda Expression at the Class which implements the functional interface
\nand provides the method definition for the abstract method in Functional Interface.<\/p>\n

    \n
  1. We have a Function Interface Printable with abstract method print<\/li>\n
  2. Two classes implements functional Interface – DailyReport and MothlyReport. They provide the method definition for Print() method in Printable Interface<\/li>\n
  3. GenerateReport class has a downloadReport method which takes the Printable Type as argument<\/li>\n
  4. DownloadReport Class we use the Printable reference and call the exact implementation by passing as argument<\/li>\n<\/ol>\n

    Printable.java<\/strong><\/p>\n

    \r\n@FunctionalInterface\r\npublic interface Printable {\r\n    public void print();\r\n}\r\n<\/pre>\n
    DailyReport.java<\/strong><\/p>\n
    \r\npublic class DailyReport implements Printable {\r\n    @Override\r\n    public void print() {\r\n        System.out.println("Printing Report in Daily Format");\r\n    }\r\n}\r\n<\/pre>\n
    MonthlyReport.java<\/strong><\/p>\n
    \r\npublic class MonthlyReport implements Printable {\r\n    @Override\r\n    public void print() {\r\n        System.out.println("Printing Report in Monthly Format");\r\n    }\r\n}\r\n<\/pre>\n
    GenerateReport.java<\/strong><\/p>\n
    \r\npublic class GenerateReport {\r\n    public static void downloadReport(Printable printable){\r\n        printable.print();\r\n    }\r\n}\r\n<\/pre>\n
    Without Lambda Expression<\/strong>
    \nDownloadReport.java<\/strong><\/p>\n
    \r\npublic class DownloadReport {\r\n    public static void main(String[] args) {\r\n        GenerateReport objGenReport = new GenerateReport();\r\n        Printable objDailyReport = new DailyReport();\r\n        Printable objMonthlyReport = new MonthlyReport();\r\n\r\n        objGenReport.downloadReport(objDailyReport);\r\n        objGenReport.downloadReport(objMonthlyReport);\r\n    }\r\n}\r\n<\/pre>\n
    Output<\/strong><\/p>\n
    \r\nPrinting Report in Daily Format\r\nPrinting Report in Monthly Format\r\n<\/pre>\n
    With Lambda Expression<\/strong>
    \nUsing Lambda expression we can pass method definition directly as parameter instead of using a class to extend interface and writing a method definition for the interface method
    \nDownloadReport.java<\/strong><\/p>\n
    \r\npublic class DownloadReport {\r\n    public static void main(String[] args) {\r\n        GenerateReport objGenReport = new GenerateReport();\r\n        objGenReport.downloadReport(() -> System.out.println("Printing Report in Daily Format using Lambda Expr"));\r\n\r\n        Printable mnthlyReport = () -> System.out.println("Printing Report in Monthly Format using Lambda Expr");\r\n        objGenReport.downloadReport(mnthlyReport);     \r\n    }\r\n}\r\n<\/pre>\n
    Output<\/strong><\/p>\n
    \r\nPrinting Report in Daily Format using Lambda Expr\r\nPrinting Report in Monthly Format using Lambda Expr\r\n<\/pre>\n\n\n\n\n
    With Lambda Expression<\/strong><\/td>\nWithout Lambda Expression<\/strong><\/td>\n<\/tr>\n
    We pass the method definition as Argument<\/td>\n\n
      \n
    1. Method Definition in MonthlyReport.java<\/li>\n
    2. Method Definition in DailyReport.java<\/li>\n
    3. Object creation for DailyReport and MonthlyReport<\/li>\n<\/ol>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Let’s take the below Example where we find the square of even numbers<\/p>\n
      ReduceEgs.java<\/strong><\/p>\n
      \r\npublic class ReduceEgs {\r\n    public static void main(String[] args) {\r\n        List<Integer> arrNumbers = Arrays.asList(1,2,4,5,7,6);\r\n\r\n        arrNumbers.stream()\r\n                  .filter(x-> x%2==0)\r\n                  .map(x->x*x)\r\n                  .forEach(System.out::println);\r\n    }\r\n}\r\n<\/pre>\n
      In the above code we have <\/p>\n
        \n
      1. Filter which takes Predicate as Param<\/li>\n
      2. Map which takes Function as Param<\/li>\n
      3. Sysout which takes Consumer as Param<\/li>\n<\/ol>\n
        The filter, Consumer and sysout have been expanded from the above code as below. <\/p>\n
        \r\npublic class ReduceEgs {\r\n        public static void main(String[] args) {\r\n            List<Integer> arrNumbers = Arrays.asList(1,2,4,5,7,6);\r\n    \r\n            arrNumbers.stream()\r\n                      .filter(getIntegerPredicate())\r\n                      .map(getFunction())\r\n                      .forEach(getPrintln());\r\n        }\r\n    \r\n        private static Consumer<Integer> getPrintln() {\r\n            return System.out::println;\r\n        }\r\n    \r\n        private static Function<Integer, Integer> getFunction() {\r\n            return x -> x * x;\r\n        }\r\n    \r\n        private static Predicate<Integer> getIntegerPredicate() {\r\n            return x -> x % 2 == 0;\r\n        }\r\n}\r\n<\/pre>\n
        The Above code is refactored as below<\/p>\n
        \r\npublic class ReduceEgs {\r\n        public static void main(String[] args) {\r\n            List<Integer> arrNumbers = Arrays.asList(1,2,4,5,7,6);\r\n\r\n            Function<Integer, Integer> getSquare = x -> x * x;\r\n            Predicate<Integer>         getEvenNo = x -> x % 2 == 0;\r\n            Consumer<Integer>          showNos   = System.out::println;\r\n\r\n            arrNumbers.stream()\r\n                      .filter(getEvenNo)\r\n                      .map(getSquare)\r\n                      .forEach(showNos);\r\n        }\r\n}\r\n<\/pre>\n
        What the java compiler does internally changes the above code as below. It created an anonymous inner class for implementing the methods in the interface.<\/p>\n
          \n
        1. Function <\/strong>has apply <\/strong>method which should be implemented<\/li>\n
        2. Consumer <\/strong>has accept <\/strong>method which should be implemented<\/li>\n
        3. Predicate <\/strong>has test <\/strong>method which should be implemented<\/li>\n<\/ol>\n
          \r\npublic class ReduceEgs {\r\n        public static void main(String[] args) {\r\n            List<Integer> arrNumbers = Arrays.asList(1,2,4,5,7,6);\r\n\r\n            Function<Integer, Integer> getSquare = new Function<Integer, Integer>() {\r\n                @Override\r\n                public Integer apply(Integer integer) {\r\n                    return integer * integer;\r\n                }\r\n            };\r\n\r\n            Predicate<Integer> getEvenNo =  new Predicate<Integer>() {\r\n                @Override\r\n                public boolean test(Integer integer) {\r\n                    return  integer % 2 == 0;\r\n                }\r\n            };\r\n\r\n            Consumer<Integer> showNos = new Consumer<Integer>() {\r\n                @Override\r\n                public void accept(Integer integer) {\r\n                    System.out.println(integer);\r\n                }\r\n            };\r\n\r\n            arrNumbers.stream()\r\n                      .filter(getEvenNo)\r\n                      .map(getSquare)\r\n                      .forEach(showNos);\r\n        }\r\n}\r\n<\/pre>\n
          The output of all the above code is one and same as below<\/p>\n
          \r\n4\r\n16\r\n36\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
          When to use Lambda Expressions If you have a functional Interface which has only one Abstract Method then we can use Lambda Expression at the Class which implements the functional interface and provides the method definition for the abstract method in Functional Interface. We have a Function Interface Printable with abstract method print Two classes… Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[250],"tags":[],"class_list":["post-4280","post","type-post","status-publish","format-standard","hentry","category-lambdas"],"_links":{"self":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/4280","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/comments?post=4280"}],"version-history":[{"count":5,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/4280\/revisions"}],"predecessor-version":[{"id":4819,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/posts\/4280\/revisions\/4819"}],"wp:attachment":[{"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/media?parent=4280"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/categories?post=4280"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codethataint.com\/blog\/wp-json\/wp\/v2\/tags?post=4280"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}