Skip to main content

Java 8 - Lambda Expression

 



Lambda expressions are known to be the biggest feature introduced with Java 8. This was the Java’s first step to Functional Programming.

Why Lambda Expressions :

  • Lambda Expression facilitates functional programming and simplifies the development a lot. 
  • It provides a clear and concise way to represent one method interface using an expression. It is very useful in the collection library. It helps to iterate, filter, and extract data from the collection.
  • The Lambda expression is used to provide the implementation of an interface that has a functional interface. It saves a lot of code. In the case of the lambda expression, we don't need to define the method again for providing the implementation. Here, we just write the implementation code.
  • Java lambda expression is treated as a function, so the compiler does not create a .class file.
  • They are used with functional interfaces: Lambda expressions are used with functional interfaces, which are interfaces with a single abstract method. Examples of functional interfaces include java.util.function.Consumer, java.util.function.Predicate, and java.util.function.Function.
  • Lambda expressions use the "->" operator: The "->" operator is used to separate the method signature from the lambda body. For example, (x, y) -> x + y is a lambda expression that takes two parameters x and y, and returns their sum.
  • They improve performance: Because Lambda expressions support parallelism, they can improve the performance of multi-threaded code.
  • They are backward compatible: Java 8 is backward compatible with previous versions of Java, so you can still use older Java code with Java 8 Lambda expressions.
  • Lambda Expressions enable you to encapsulate a single unit of behavior and pass it to other code. You can use lambda expressions if you want a certain action performed on each element of a collection, when a process is completed, or when a process encounters an error.

Functional Interface


A functional interface is an interface in Java that has only one abstract method. It is also known as a Single Abstract Method (SAM) interface. Functional interfaces are the cornerstone of functional programming in Java, and they are used extensively in conjunction with lambda expressions.

@FunctionalInterface
interface MyFunctionalInterface {
    void test();
}

@FunctionalInterface annotation is optional but recommended  which ensures that interface has only one abstract method.
Functional interfaces can also have default methods and static methods, but they can have only one abstract method.

Here is an example of functional interface which contains default and static method:

@FunctionalInterface
interface MyFunctionalInterface {
    void test();
    default void test() {
        System.out.println("contains default method");
    }
}


Java 8 Lambda Expression :

// syntax of lambda expressions
(parameters) - > {body}

Java Lambda Expression Syntax :

The Syntax of Lambda Expression in Java consists of three components.

parameters: It is the first portion of the Lambda expression in Java. It can also be empty or non-empty. In the expression, it is enclosed by a round bracket.
Lambda operator ->: It's an arrow sign that appears after the list of arguments. It connects the arguments-list with the body of the expression.
Body: It contains the function body of lambda expression. It is surrounded by curly brackets.


Lambda Expression Examples :

lambda expression with no parameter :
() -> {return "something"}

Lambda expression with one parameter and no return value:
(someStr) -> {system.out.println(someStr)}

Lambda expression with multiple parameter and return value:
(a, b) -> {return a+b}

Lambda expression with a block of code:
(a , b) -> {
 int mul = a*b;
 System.out.println("The multiplication is: " + mul);
return mul;
}

Lambda expression with method reference:
String[] fruits = {"Mango", "Apple", "Pineapple"};
Arrays.sort(fruits, String::toUppercase);



 




Comments

Post a Comment

Popular posts from this blog

How to create Annotation in Spring boot

 To create Custom Annotation in JAVA, @interface keyword is used. The annotation contains :  1. Retention :  @Retention ( RetentionPolicy . RUNTIME ) It specifies that annotation should be available at runtime. 2. Target :  @Target ({ ElementType . METHOD }) It specifies that the annotation can only be applied to method. The target cane be modified to:   @Target ({ ElementType . TYPE }) for class level annotation @Target ({ ElementType . FIELD }) for field level annotation @Retention ( RetentionPolicy . RUNTIME ) @Target ({ ElementType . FIELD }) public @ interface CustomAnnotation { String value () default "default value" ; } value attribute is defined with @ CustomAnnotation annotation. If you want to use the attribute in annotation. A single attribute value. Example : public class Books {           @CustomAnnotation(value = "myBook")     public void updateBookDetail() {         ...
Post a Comment
Read more

Kafka And Zookeeper SetUp

 Kafka And Zookeeper SetUp zookeeper download Link : https://www.apache.org/dyn/closer.lua/zookeeper/zookeeper-3.8.3/apache-zookeeper-3.8.3-bin.tar.gz Configuration: zoo.conf # The number of milliseconds of each tick tickTime =2000 # The number of ticks that the initial # synchronization phase can take initLimit =10 # The number of ticks that can pass between # sending a request and getting an acknowledgement syncLimit =5 # the directory where the snapshot is stored. # do not use /tmp for storage, /tmp here is just # example sakes. dataDir =/tmp/zookeeper # the port at which the clients will connect clientPort =2181 4 char whitelist in command arguments 4lw.commands.whitelist =* Start ZooKeeper Server $ bin/zkServer.sh start Check zookeeper status dheeraj.kumar@Dheeraj-Kumar bin % echo stat | nc localhost 2181 stat is 4 character whitelisted argument  Check Kafka running status : echo dump | nc localhost 2181 | grep broker Responsibility of Leader in Zookeeper: 1. Distrib...
Post a Comment
Read more

Cache Policy

Cache policies determine how data is stored and retrieved from a cache, which is a small and fast storage area that holds frequently accessed data to reduce the latency of accessing that data from a slower, larger, and more distant storage location, such as main memory or disk. Different cache policies are designed to optimize various aspects of cache performance, including hit rate, latency, and consistency. Here are some common types of cache policies: Least Recently Used (LRU): LRU is a commonly used cache replacement policy. It evicts the least recently accessed item when the cache is full. LRU keeps track of the order in which items were accessed and removes the item that has not been accessed for the longest time. First-In-First-Out (FIFO): FIFO is a simple cache replacement policy. It removes the oldest item from the cache when new data needs to be stored, regardless of how frequently the items have been accessed. Most Recently Used (MRU): MRU removes the most recently accessed ...
Post a Comment
Read more