{"id":5265,"date":"2021-03-23T16:22:50","date_gmt":"2021-03-23T16:22:50","guid":{"rendered":"https:\/\/ded9.com\/?p=5265"},"modified":"2026-02-16T09:00:09","modified_gmt":"2026-02-16T09:00:09","slug":"learn-lambda-expressions-in-java-lambda-expressions","status":"publish","type":"post","link":"https:\/\/ded9.com\/tr\/learn-lambda-expressions-in-java-lambda-expressions\/","title":{"rendered":"Mastering Lambda Expressions in Java: A Clear, Practical Guide"},"content":{"rendered":"

When Java 8 was released, lambda expressions were a hot topic. Lambda expressions<\/a> have been added to JDK version 8 to enhance Java performance by increasing the language’s expressive power.<\/span><\/p>\n

But before entering Lambda, we must first know the user interface.<\/p>\n

What is a user interface?<\/span><\/h2>\n

If a Java interface contains only one abstract method, it is called a functional interface. For example, the Runnable interface of the package, Java.lang, is functional because it forms only one method, run ().<\/p>\n

Example 1: Define a user interface or interface in Java<\/strong><\/p>\n

\n
    \n
  1. import java.lang.FunctionalInterface;<\/li>\n
  2. @FunctionalInterface<\/li>\n
  3. public interface MyInterface {<\/li>\n
  4. double getValue ();<\/li>\n
  5. }<\/li>\n<\/ol>\n<\/blockquote>\n

    Note:<\/strong>\u00a0Annotating @ FunctionalInterface is not necessary, but it is wise to use it because the Java compiler forces the defined interface to be a functional interface and should only have an abstract method.\u00a0In Java 7, the interface was called the Abstract Method Single or SAM type.<\/p>\n

    SAM was usually run with anonymous classes in Java 7.<\/p>\n

    Example 2: Run SAM with anonymous classes in Java<\/strong><\/p>\n

    \n
      \n
    1. public class FunctionInterfaceTest {<\/li>\n
    2. public static void main (String [] args) {<\/li>\n
    3. new Thread (new Runnable () {<\/li>\n
    4. @Override<\/li>\n
    5. public void run () {<\/li>\n
    6. System.out.println (“I just implemented the Runnable Functional Interface.”);<\/li>\n
    7. }<\/li>\n
    8. }). start ();<\/li>\n
    9. }<\/li>\n
    10. }<\/li>\n<\/ol>\n<\/blockquote>\n

      The ability to send an anonymous class to the constructor or method made writing Java 7 code with fewer files easy. However, the structure was still tricky, and a lot of code was needed.<\/p>\n

      Java 8 went one step further, increasing the power of a SAM.\u00a0Since we know that an interface has only one method, there is no need to define the name of that method when sending it as an argument.\u00a0The term lambda allows us to do just that.<\/p>\n

      Familiarity with the term lambda<\/h2>\n

      Lambda is essentially an unknown or unspecified method that is not executed alone. Instead, it implements the method defined by the interface.<\/p>\n

      How do you define the term lambda in Java?<\/strong><\/h2>\n

      The term lambda introduces a new syntactic element and operator in Java.\u00a0The new operator is called the lambda operator or the arrow operator.\u00a0(->)<\/p>\n

      Let’s write a simple method that returns only a constant double value.<\/p>\n

      \n
      double getPiValue () {return 3.1415; }<\/pre>\n<\/div>\n
      The lambda expression equivalent to the above method is:<\/h3>\n
      \n
      () -> 3.1415<\/pre>\n<\/div>\n
      In the lambda expression, the left side specifies the required parameters of the expression, while the right is the lambda body, which determines the function of the lambda expression.<\/p>\n
      The Lambda body is of two types.<\/p>\n
      1- Body with a single phrase<\/p>\n
      \n
      () -> System.out.println (\u201cLambdas are great\u201d);<\/pre>\n<\/div>\n
      2- The body consists of a block of code<\/p>\n
      \n
      () -> {\r\n\r\ndouble pi = 3.1415;\r\n\r\nreturn pi;\r\n\r\n}<\/pre>\n<\/div>\n
      A lambda expression can have a parameter. For example:<\/span><\/h3>\n
      \n
      (n) -> (n% 2) == 0<\/pre>\n<\/div>\n
      This lambda expression specifies that the value of n is even or odd.<\/p>\n
      If the body of the Lambda is a block of code, you should always return a value. However, a return value is not required if the lambda body is just a phrase.<\/p>\n
      Let’s write the Java code <\/a>with the lambda expression that returns the value of Pi<\/a>.<\/p>\n
      As mentioned earlier, the term lambda is not used alone. Executing the abstract method defined by the interface constitutes a function.<\/p>\n
      Example 3: Define the term Lambda with the user interface (interface) in Java<\/strong><\/p>\n
      We must first define a MyInterface.java user interface:<\/p>\n
      \n
        \n
      1. import java.lang.FunctionalInterface;<\/li>\n
      2. \/\/ This is functional interface<\/li>\n
      3. @FunctionalInterface<\/li>\n
      4. public interface MyInterface {<\/li>\n
      5. double getPiValue ();<\/li>\n
      6. }<\/li>\n<\/ol>\n<\/blockquote>\n
        Now, let’s take the lambda expression as an example of a functional interface.<\/p>\n
        \n
          \n
        1. public class LambdaMain {<\/li>\n
        2. public static void main (String [] args) {<\/li>\n
        3. MyInterface myInterface;<\/li>\n
        4. myInterface = () -> 3.1415;<\/li>\n
        5. <\/li>\n
        6. System.out.println (\u201cValue of Pi =\u201d + myInterface.getPiValue ());<\/li>\n
        7. }<\/li>\n
        8. }<\/li>\n<\/ol>\n<\/blockquote>\n
          The output is equal to:<\/h4>\n
          \n
          Value of Pi = 3.1415<\/pre>\n<\/div>\n
          The lambda expression must be consistent with the abstract method. That is, if you assign () -> “3.1415” to the myInterface instance, the code is defective and will not run because, by definition in the interface, the string type is not compatible with double.<\/p>\n
          You probably do not use a lambda phrase like the above in a real application. Let’s look at another example of a lambda expression that takes parameters.<\/p>\n
          Example 4: Using the term lambda with parameters in Java<\/strong><\/p>\n
          \"Example<\/strong><\/p>\n
          \n
            \n
          1. @FunctionalInterface<\/li>\n
          2. MyInterface {interface<\/li>\n
          3. Reverse string (String n);<\/li>\n
          4. }<\/li>\n
          5. public class ParamLambdaMain {<\/li>\n
          6. public static void main (String [] args) {<\/li>\n
          7. MyInterface myInterface = (str) -><\/li>\n
          8. String result = \u201c\u201d;<\/li>\n
          9. for (int i = str.length () – 1; i> = 0; i\u2013)<\/li>\n
          10. result + = str.charAt (i);<\/li>\n
          11. return result;<\/li>\n
          12. };<\/li>\n
          13. System.out.println (\u201cLambda reversed =\u201d + myInterface.reverse (\u201cLambda\u201d));<\/li>\n
          14. }<\/li>\n
          15. }<\/li>\n<\/ol>\n<\/blockquote>\n
            Output<\/p>\n
            \n
            Lambda reversed = adbmaL<\/p>\n<\/blockquote>\n
            General functional interface<\/h2>\n
            The above interface only accepts String and returns the StrStringject. However, we can create a public user interface that accepts any data type.<\/p>\n
            Example 5: How can a user interface accept any data type in Java?<\/strong><\/p>\n
            Let’s see how this is done:<\/p>\n
            \n
              \n
            1. \/\/ GenericInterface.java<\/li>\n
            2. @FunctionalInterface<\/li>\n
            3. interface GenericInterface <T> {<\/li>\n
            4. T func (T t);<\/li>\n
            5. }<\/li>\n<\/ol>\n<\/blockquote>\n
              Now, the Generic Interface is compatible with any Lambda expression that takes a parameter and returns a value of the same type.<\/h4>\n
              \n
                \n
              1. \/\/ GenericLambda.java<\/li>\n
              2. public class GenericLambda {<\/li>\n
              3. public static void main (String [] args) {<\/li>\n
              4. GenericInterface <String> reverse = (str) -> {<\/li>\n
              5. String result = \u201c\u201d;<\/li>\n
              6. for (int i = str.length () – 1; i> = 0; i\u2013)<\/li>\n
              7. result + = str.charAt (i);<\/li>\n
              8. return result;<\/li>\n
              9. };<\/li>\n
              10. System.out.println (“Lambda reversed =” + reverse.func (“Lambda”));<\/li>\n
              11. GenericInterface <Integer> factorial = (n) -> {<\/li>\n
              12. int result = 1;<\/li>\n
              13. for (int i = 1; i <= n; i ++)<\/li>\n
              14. result = i * result;<\/li>\n
              15. return result;<\/li>\n
              16. };<\/li>\n
              17. System.out.println (\u201cfactorial of 5 =\u201d + factorial.func (5));<\/li>\n
              18. }<\/li>\n
              19. }<\/li>\n<\/ol>\n<\/blockquote>\n
                Output<\/p>\n
                \n
                Lambda reversed = adbmaL<\/p>\n
                factorial of 5 = 120<\/p>\n<\/blockquote>\n
                Lambda Expressions and API flow<\/h2>\n
                \"Lambda<\/h2>\n
                A new Java. Util. The stream package has been added to JDK8, which allows Java programmers to perform operations such as search, filter, map, reduce, or otherwise manipulate collections such as lists.<\/p>\n
                For example, we have a data stream (a string list) in which each String combines the country’s String and the country’s location. Now, we can process this data stream and retrieve only the Nepal locations.<\/p>\n
                Example 6: Demonstrate the use of Lambda with the API stream<\/strong><\/p>\n
                \n
                  \n
                1. import java.util.ArrayList;<\/li>\n
                2. import java.util.List;<\/li>\n
                3. public class StreamMain {<\/li>\n
                4. static List <String> places = new ArrayList <> ();<\/li>\n
                5. \/\/ preparing our data<\/li>\n
                6. public static List getPlaces () {<\/li>\n
                7. places.add (\u201cNepal, Kathmandu\u201d);<\/li>\n
                8. places.add (\u201cNepal, Pokhara\u201d);<\/li>\n
                9. places.add (\u201cIndia, Delhi\u201d);<\/li>\n
                10. places.add (“USA, New York”);<\/li>\n
                11. places.add (\u201cAfrica, Nigeria\u201d);<\/li>\n
                12. return places;<\/li>\n
                13. }<\/li>\n
                14. public static void main (String [] args) {<\/li>\n
                15. List <String> myPlaces = getPlaces ();<\/li>\n
                16. System.out.println (\u201cPlaces from Nepal:\u201d);<\/li>\n
                17. <\/li>\n
                18. \/\/ Filter places from Nepal<\/li>\n
                19. myPlaces.stream ()<\/li>\n
                20. .filter ((p) -> p.startsWith (\u201cNepal\u201d))<\/li>\n
                21. .map ((p) -> p.toUpperCase ())<\/li>\n
                22. .sorted ()<\/li>\n
                23. .forEach ((p) -> System.out.println (p));<\/li>\n
                24. }<\/li>\n
                25. }<\/li>\n<\/ol>\n<\/blockquote>\n
                  Output<\/h4>\n
                  \n
                  Places from Nepal:<\/p>\n
                  NEPAL, KATHMANDU<\/p>\n
                  NEPAL, POKHARA<\/p>\n<\/blockquote>\n
                  The API stream allows us to access methods such as filter (), map, and forEach () that can take a lambda expression as input.<\/p>\n
                  We can use both built-in Java methods and define our expressions based on the technique we learned above. As we saw in the example above, this dramatically reduces the lines of code.<\/p>\n
                  FAQ<\/h2>\n
                  \n
                  \n
                  \n
                  What is a lambda expression in Java and why was it added?<\/h3>\n
                  \n\n
                  A lambda expression is essentially an anonymous method \u2014 a short block of code that you can pass around like an object, to implement a single-method (functional) interface. It was introduced in Java 8 to reduce boilerplate code, especially where anonymous classes were previously used.<\/p>\n\n<\/div>\n<\/div>\n
                  \n
                  What is the basic syntax of a lambda expression?<\/h3>\n
                  \n\n
                  The basic form is: (parameters) -> { body } For example: (a, b) -> a + b If there\u2019s only one parameter and the type can be inferred, parentheses can be omitted: x -> x * x<\/p>\n\n<\/div>\n<\/div>\n
                  \n
                  When and how should I use lambda expressions effectively?<\/h3>\n
                  \n\n
                  Use lambdas when you need to implement a functional interface (an interface with exactly one abstract method). Common applications include passing behavior as an argument (for example, to forEach, filter, map on collections), sorting with comparators, or event handling. It\u2019s best to use standard functional interfaces from java.util.function (like Predicate, Consumer, Function) instead of creating custom ones unless necessary.<\/p>\n\n<\/div>\n<\/div>\n<\/div>\n<\/div><\/div>\n","protected":false},"excerpt":{"rendered":"
                  When Java 8 was released, lambda expressions were a hot topic. Lambda expressions have been added to JDK version 8 to enhance Java performance by increasing the language’s expressive power. But before entering Lambda, we must first know the user interface. What is a user interface? If a Java interface contains only one abstract method, […]<\/p>\n","protected":false},"author":6,"featured_media":5266,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[11513],"tags":[840,11982],"class_list":["post-5265","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-2","tag-java","tag-pi"],"acf":[],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/5265","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/comments?post=5265"}],"version-history":[{"count":5,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/5265\/revisions"}],"predecessor-version":[{"id":267011,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/5265\/revisions\/267011"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/media\/5266"}],"wp:attachment":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/media?parent=5265"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/categories?post=5265"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/tags?post=5265"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}