The Use of Lambda Expressions in Java Development

1. So, what the heck is a Lambda expression?

To put it simply, a Lambda expression is like a “laziness booster” that Java 8 gifted us hardworking developers. It lets you write cleaner, more elegant code. 

In plain terms: it kicks out those long-winded, smelly anonymous inner classes and gives your code-base a fresh, minimalist vibe.

Especially when you’re wrangling collections like `List`, `Map`, and the like—once you bring in a Lambda, your code shrinks in half and suddenly feels way more readable.

Here's an example without Lambda (Traditional Java approach) : 

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Print names in uppercase (before Java 8)
for (String name : names) {
    System.out.println(name.toUpperCase());
}
Here's an example with Lambda (Java 8 or later) : 
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Print names in uppercase using lambda
names.forEach(name -> System.out.println(name.toUpperCase()));

Back in the day, if you wanted to handle a button click, you had to either `new` up a listener or write a bunch of interfaces. Now? Just one Lambda line and done. It’s like a programmer’s dream tool for getting more done with less typing.

But you can’t just go slapping Lambdas everywhere. They need a trusty sidekick called a functional interface. 

What’s that? 

Easy—just an interface with one abstract method. Not two, not three—just one. Be greedy and try to sneak in more? Java’s not having it.

Of course, you can create your own functional interfaces, but Java’s got you covered with a bunch of ready-made ones like `Runnable`, `Callable`, `Comparator`, and more. Just grab one and roll with it—super convenient!

2. Functional Interfaces

If an interface is marked with the @FunctionalInterface annotation, then it's officially a functional interface—which means it can only have one abstract method. Here's an example of what a functional interface looks like:

@FunctionalInterface
public interface MyInterface {
    void eat();
}

Even if you don’t add the @FunctionalInterface annotation, as long as the interface contains only one abstract method, it still counts as a functional interface in the eyes of Java.

public interface MyInterface {
    void eat();
}

There’s only one exception to the “only one method” rule: a functional interface can still inherit methods from the Object class—like toString(), equals(), or hashCode()—and that’s totally allowed.

@FunctionalInterface
public interface MyInteface3 {
    void eat();

    @Override
    String toString();

    @Override
    int hashCode();
}

3. Using Lambda Expressions

Usage inside regular methods

Student class:

@FunctionalInterface
public interface Student {
    void eat();
}

Test class:

public class Test {
    public static void main(String[] args) {
        Student stu = new Student() {
            // Regular method: override and use
            @Override
            public void eat() {
                System.out.println("I am a student");
            }
        };
        stu.eat();

        // Lambda expression version:
        // Part 1: overrides the single parameterless abstract method 'eat' in Student interface, providing implementation, so no need to write method name
        // Part 2: -> operator, fixed syntax
        // Part 3: {implementation body} provides the concrete implementation of the 'eat' method in Student interface
        Student stu2 = () -> {
            System.out.println("Student is eating");
        };
        stu2.eat();
    }
}
Output: 
I am a student
Student is eating
Using methods with parameters

Student class:
@FunctionalInterface
public interface Student {
    void eat(String food);
}
Test class:
public class Test {
    public static void main(String[] args) {
        // Using lambda to override the only method in the Student interface
        Student stu2 = (foodName) -> {
            System.out.println("The student is eating " + foodName);
        };
        stu2.eat("meat");  // Output: The student is eating meat
    }
}
4. Implementing Multi-threading with Lambda Expressions

Creating threads using Lambda:
public class Test {
    public static void main(String[] args) {
        // Creating a thread using a lambda expression
        Thread t = new Thread(() -> {
            System.out.println("This thread is created using lambda");
        });
        t.start();
    }
}
5. Performing Operations with Lambda Expressions

Using Lambda expressions for operations can greatly reduce the amount of code.
Functional interface:
@FunctionalInterface
public interface Calculator<T> {
    T operation(T v1, T v2);
}
Test Class:
public class Test {
    // Calculation method
    public static Integer operator(Integer v1, Integer v2, Calculator<Integer> calculator) {
        return calculator.operation(v1, v2);
    }

    public static void main(String[] args) {
        // Using a lambda expression:
        // This means passing in two parameters and returning the result
        int add = Test.operator(5, 10, (x, y) -> {
            return x + y;
        });

        // Simplified version: much shorter and cleaner than above
        int num1 = Test.operator(6, 12, (x, y) -> x + y);
        int num2 = Test.operator(12, 6, (x, y) -> x - y);

        System.out.println(add);
        System.out.println(num1);
        System.out.println(num2);
    }
}
Output: 
18 、18 、6

6. Lambda Method References

Sometimes, we don’t necessarily need to override the method of an interface with a new implementation.

If there’s already an existing method that fits the purpose, we can use method references to reuse it for the functional interface’s implementation.

The benefit is code reuse. For example, with a functional interface:
public interface ResultOneParam {
    int method(int a);
}
Test Class:
public class Test {

    // An instance method that adds 10 to the input
    public int addTo(int a) {
        return a + 10;
    }

    // A static method that also adds 10 to the input
    public static int addTo2(int a) {
        return a + 12;
    }

    public static void main(String[] args) {
        // Lambda expression that overrides the method in the interface
        ResultOneParam lambda1 = (a) -> a + 12;

        // Method reference: uses the existing static method addTo2 in Test class 
        // as the implementation of the method in the interface
        ResultOneParam lambda2 = Test::addTo2;
        int result1 = lambda2.method(9);
        System.out.println(result1);

        // Method reference :: reuses an existing method instead of writing a new one
        Test test = new Test();
        ResultOneParam lambda3 = test::addTo;
        int result2 = lambda3.method(9);
        System.out.println(result2);
    }
}


7. Using Lambda with Collections
Lambda expressions are also very convenient for operating on collections.

They allow you to write much less code when iterating or processing data in collections.
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(6, 10, 1, 4, 5, 0, 7, 5, 0, 1, 5);

        // Using a lambda expression to iterate over the list
        // This overrides the accept method of the Consumer interface
        list.forEach((element) -> {
            System.out.println(element);
        });

        // Simplified version:
        list.forEach(element -> System.out.println(element));

        // Lambda expression with method reference to print elements in the list
        list.forEach(System.out::print);

        // Print only even numbers in the list:
        list.forEach(element -> {
            if (element % 2 == 0) {
                System.out.println(element);
            }
        });
    }
}

Comments

Post a Comment

Popular posts from this blog

Why Do Remote Java Transmission Objects Need to Be Serialized?

1. Introduction Serialization and deserialization are tasks that java engineers deal with almost every day, especially in today’s popular microservices development.  Just looking at the definition, it might be hard for beginners to immediately grasp the significance of serialization—especially when faced with such academic terminology. Naturally, one might wonder: What exactly is it, and what is it used for? From a programming perspective, we know that the smallest unit of data exchanged between computers is the byte stream . Serialization is the process of converting an object into a byte stream that any computer can recognize, while deserialization is converting this byte stream back into an object that a program can understand. Simply put, the ultimate purpose of serialization is to make objects easier to store across platforms and transmit over networks. Basically, any data that involves cross-platform storage or network transmission needs to be serialized. In the early days o...
Read more

Usage of MD5 Encryption and Decryption Technology in Java Application Development

Image
MD5 (Message Digest Algorithm 5) is a widely used hash function that generates a 128-bit (16-byte) hash value. It is important to note that MD5 is a one-way encryption algorithm, meaning it cannot theoretically be decrypted (it can only be cracked through collision attacks or rainbow tables). 1. Core Characteristics of MD5 One-way: Irreversible operation; the original data cannot be recovered from the hash value. Fixed Length: Regardless of the input length, the output is always 128 bits. Avalanche Effect: A tiny change in the input will cause a large difference in the output. Collision Resistance (No Longer Valid): In theory, different inputs should not produce the same output, but collisions have been proven to be artificially created. 2. Algorithm Processing Steps Data Padding: Padding the data so that its length = 448 mod 512. Appending Length: After padding, appending a 64-bit representation of the original data length. Initializing Variables: Initializing four 32-bit registers (A...
Read more

For storing mobile phone numbers of 3 billion global users, should the data type be int, string, varchar, or char? And why?

Image
With platforms like Facebook and YouTube each hosting over 2.5 to 3 billion users globally, the scale of user data storage has become increasingly complex. If every valid user is required to register with a mobile phone number, this results in billions of phone numbers to be stored and managed. Given that most countries use mobile numbers ranging from 10 to 11 digits, several challenges arise. One of the key challenges we need to address is: if we are storing 3 billion mobile phone numbers, should we use int or string? varchar or char? And why? With 3 billion records, what problems might arise if we use Int or BigInt? 1.1 Can an Int hold an 10 or 11-digit phone number? First, we all know that mobile phone numbers typically have 10 or 11 digits—for example, 01511234567.  In Java, the int type is 32-bit, with a maximum value of 2³¹ - 1, which equals 2,147,483,647 (approximately 2 × 10⁹). Clearly, this is not enough to store an 11-digit phone number.  To store such numbers, we wo...
Read more