Lambda Expressions in Java: Explained in Easy Steps

(argument-list) -> {body}

() -> System.out.println("Zero parameter lambda");

(p) -> System.out.println("One parameter: " + p);

(p1, p2) -> System.out.println("Multiple parameters: " + p1 + ", " + p2);

@FunctionalInterface
interface ScholarHat {
    void learn(); // Single abstract method
}

@FunctionalInterface
interface ScholarHat {
    void study(); // Single abstract method
}

public class LambdaExample {
    public static void main(String[] args) {
        // Using a lambda expression to implement the ScholarHat interface
        ScholarHat learningSession = () -> System.out.println("Studying with ScholarHat!");
        learningSession.study();  // Output: Studying with ScholarHat!
    }
}

Studying with ScholarHat!

@FunctionalInterface
interface Greet {
    // Single abstract method for the functional interface
    void sayHello();
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression implementing the sayHello method of the Greet interface
        Greet greeting = () -> System.out.println("Hello, World!");
        
        // Calling the sayHello method, which executes the lambda expression
        greeting.sayHello(); 
    }
}

Hello, World!

@FunctionalInterface
interface Square {
    // Single abstract method that takes an integer and returns its square
    int calculate(int x);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression implementing the calculate method of the Square interface
        Square square = x -> x * x;
        
        // Calling the calculate method with the argument 5, which computes 5 * 5
        System.out.println(square.calculate(5));  
    }
}

25

@FunctionalInterface
interface Add {
    // Single abstract method that takes two integers and returns their sum
    int sum(int a, int b);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression implementing the sum method of the Add interface
        Add addition = (a, b) -> a + b;
        
        // Calling the sum method with arguments 10 and 20, which computes 10 + 20
        System.out.println(addition.sum(10, 20));
    }
}

30

@FunctionalInterface
interface Multiply {
    // Single abstract method that takes two integers and returns their product
    int multiply(int a, int b);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression implementing the multiply method of the Multiply interface
        Multiply multiplication = (a, b) -> {
            // Calculate the product of a and b
            int result = a * b;
            // Return the result
            return result;
        };
        
        // Calling the multiply method with arguments 4 and 5, which computes 4 * 5
        System.out.println(multiplication.multiply(4, 5)); 
    }
}

20

@FunctionalInterface
interface Printer {
    // Single abstract method that takes a String message and prints it
    void print(String message);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Method reference to System.out.println, 
        //implementing the print method of the Printer interface
        Printer printer = System.out::println;
        
        // Calling the print method with the message "Hello, Method Reference!"
        printer.print("Hello, Method Reference!");  // Output: Hello, Method Reference!
    }
}

Hello, Method Reference!

@FunctionalInterface
interface Greet {
    void sayHello();
}

public class ScholarHat {
    public static void main(String[] args) {
        // Implementing the Greet interface using an anonymous class
        Greet greeting = new Greet() {
            @Override
            public void sayHello() {
                System.out.println("Hello from ScholarHat!");
            }
        };
        
        // Calling the sayHello method
        greeting.sayHello();
    }
}

Hello from ScholarHat!

@FunctionalInterface
interface Greet {
    // Single abstract method to be implemented
    void sayHello();
}

public class ScholarHat {
    public static void main(String[] args) {
        // Implement the Greet interface using a lambda expression
        Greet greeting = () -> System.out.println("Hello from ScholarHat!");
        
        // Call the sayHello method of the Greet instance
        greeting.sayHello();
    }
} 

Hello from ScholarHat!

import java.util.Arrays;
import java.util.List;

public class ScholarHat {
    public static void main(String[] args) {
        // Define a list of strings
        List names = Arrays.asList("Aman", "Bhanu", "Charu", "Dev");
        
        // Iterate over the list using forEach and a lambda expression
        names.forEach(name -> System.out.println(name));
    }
}

Aman
Bhanu
Charu
Dev

@FunctionalInterface
interface Square {
    int calculate(int x);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression without return keyword
        Square square = x -> x * x;
        
        // Calling the calculate method
        System.out.println(square.calculate(5));  // Output: 25
    }
}

25

@FunctionalInterface
interface Square {
    int calculate(int x);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression with return keyword
        Square square = x -> {
            int result = x * x;
            return result;
        };
        
        // Calling the calculate method
        System.out.println(square.calculate(5));
    }
}

25

public class LambdaThreadExample {
    public static void main(String[] args) {
        // Creating a thread using a lambda expression
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Running in thread: " + Thread.currentThread().getName() + ", Count: " + i);
                try {
                    Thread.sleep(500); // Sleep for 500 milliseconds
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        // Start the thread
        thread.start();
        
        // Main thread output
        for (int i = 0; i < 5; i++) {
            System.out.println("Running in main thread: " + Thread.currentThread().getName() + ", Count: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Running in thread: Thread-0, Count: 0
Running in main thread: main, Count: 0
Running in thread: Thread-0, Count: 1
Running in main thread: main, Count: 1
Running in thread: Thread-0, Count: 2
Running in main thread: main, Count: 2
Running in thread: Thread-0, Count: 3
Running in main thread: main, Count: 3
Running in thread: Thread-0, Count: 4
Running in main thread: main, Count: 4

import java.util.Arrays;
import java.util.List;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        // Define a list of strings
        List names = Arrays.asList("Aman", "Ankita", "Raghav", "Prince");
        
        // Sort the list in natural order using a lambda expression
        names.sort((s1, s2) -> s1.compareTo(s2));
        
        // Print the sorted list
        System.out.println("Sorted names: " + names);
    }
}

Sorted names: [Aman, Ankita, Prince, Raghav]

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaFilterExample {
    public static void main(String[] args) {
        // Define a list of strings
        List names = Arrays.asList("Aman", "Ankita", "Radha", "Price", "Abhishek");

        // Filter the list to include only names that start with "A"
        List filteredNames = names.stream()
                                          .filter(name -> name.startsWith("A"))
                                          .collect(Collectors.toList());

        // Print the filtered list
        System.out.println("Filtered names: " + filteredNames);
    }
}

Filtered names: [Aman, Ankita, Abhishek]

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class LambdaEventListenerSwing {
    public static void main(String[] args) {
        // Create the JFrame
        JFrame frame = new JFrame("Lambda Event Listener Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);

        // Create a JPanel
        JPanel panel = new JPanel();

        // Create a JButton
        JButton button = new JButton("Click Me!");

        // Add ActionListener using lambda expression
        button.addActionListener(event -> System.out.println("Button clicked!"));

        // Add button to panel
        panel.add(button);

        // Add panel to frame
        frame.add(panel);

        // Make the frame visible
        frame.setVisible(true);
    }
}