Local variable type inference in Java 10: How to use var keyword in lambda expression

Local variable type inference in Java 10: How to use the var keyword in lambda expressions

Introduction:
Java 10 introduces a new feature of local variable type inference, which allows us to Use the var keyword when declaring a local variable to infer its type. While this feature may not be necessary in most cases, in some cases it can improve code readability and simplicity. This article will focus on how to use the var keyword in lambda expressions to implement local variable type inference.

What is local variable type inference?
In earlier versions of Java, we had to explicitly specify the type of a local variable when declaring it. For example:

String name = "John";
int age = 25;

However, starting from Java 10, we can use the var keyword to let the compiler automatically infer the type of the variable based on the expression on the right without having to specify it explicitly. For example:

var name = "John";
var age = 25;

In this example, the compiler will infer that the type of name is String and the type of age is int based on the expression on the right.

Benefits of using the var keyword in lambda expressions:
When using lambda expressions, we usually create an instance of a functional interface to pass to other methods. Using the var keyword saves us the trouble of specifying parameter types when creating lambda expression instances. In this way, we can focus more on the logic of the lambda expression without paying too much attention to the declaration of the parameter type.

Sample code:
Suppose we have a class named Person, which contains two attributes: name and age:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Now, we want to sort based on the name attribute of Person objects . Before Java 10, we needed to manually specify the generic type of Comparator:

List<Person> persons = // 初始化Person对象列表

Collections.sort(persons, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
});

In this example, we created an anonymous inner class to implement the Comparator interface and overridden the compare method in it. However, the var keyword in Java 10 makes the code cleaner:

List<Person> persons = // 初始化Person对象列表

Collections.sort(persons, (var p1, var p2) -> {
    return p1.getName().compareTo(p2.getName());
});

In this example, we use the var keyword to infer the types of p1 and p2 without having to explicitly declare their types as Person.

Conclusion:
Local variable type inference in Java 10 is a powerful feature that allows us to write cleaner and more readable code. Using the var keyword in a lambda expression allows us to focus on the implementation of the logic without having to pay too much attention to the type declaration of the parameters. Of course, although this feature can be very useful in some situations, we still need to use it with caution to ensure the maintainability and readability of the code.

Reference materials:

• Oracle official documentation: https://docs.oracle.com/en/java/javase/10/language/local-variable-type-inference. html
• Java Lambda expression tutorial: https://www.javatpoint.com/java-lambda-expressions

The above is the detailed content of Local variable type inference in Java 10: How to use var keyword in lambda expression. For more information, please follow other related articles on the PHP Chinese website!