Think of a lambda expression as a shortened syntax for the compiler (similar to when we program on IDEs, just typing psvm + Tab will get the function “public static void main (String [] args)”), when The compiler sees the lambda syntax, it expands into two parts: the class definition and the class constructor.
If you think of it as a tool to shorten your code, you’ll love it, to the point where you’ll find ways to utilize it whenever possible.
Let’s take a look at a simple example of a CarMall mall, where there are many different Cars:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | public class CarMall { private List<Car> cars; public CarMall() { cars = new ArrayList<>(); cars.add(new Car("Honda", "City 2021")); cars.add(new Car("Honda", "Civic 2021")); cars.add(new Car("Honda", "Accord")); cars.add(new Car("Honda", "CRV")); cars.add(new Car("Toyota", "Vios")); cars.add(new Car("Honda", "Fortuner Legender")); cars.add(new Car("Honda", "Innova")); } public void showCars(CarFilter filter) { for(Car car: cars){ if(filter.confirm(car)) System.out.println(car); } } } |
In which, CarFilter:
1 2 3 4 | public interface CarFilter { boolean confirm(Car car); } |
With Car:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | public class Car { private String producer; private String name; public Car(String producer, String name) { this.producer = producer; this.name = name; } public String getProducer() { return producer; } public String getName() { return name; } } |
If we do the usual way, we will create a class that implements the CarFilter interface:
1 2 3 4 5 6 7 8 9 10 11 12 13 | public class CarFilterImpl implements CarFilter { private String producer; public CarFilterImpl(String producer) { this.producer = producer; } @Override public boolean confirm(Car car) { return this.producer.equals(car.getProducer()); } } |
At that time, the code to print all Honda cars is:
1 2 3 4 | CarMall carMall = new CarMall(); CarFilter carFilter = new CarFilterImpl("Honda"); carMall.showCars(carFilter); |
However, if we use a lambda expression, we don’t need to initialize the class implement CarFilter, and the code to print out Honda cars only needs:
1 2 3 | CarMall carMall = new CarMall(); carMall.showCars(c -> c.getProducer().equals("Honda")); |
This reduces the load of about a dozen lines of code (because there is no need to initialize CarFilterImpl).
But why? How can we code like that and still be understood by the compiler?
In essence, all the information needed to “extend” is already available in the function carMall.showCars (…) . The compiler knows that it needs to pass an object of the class that implements the CarFilter interface into the showCars (CarFilter filter) function , and that this object needs to implement the function: * boolean confirm (Car car) * because it is the only function in the interface. . It also knows that the content in the function will be equivalent to expression: c -> c.getProducer (). Equals (“Honda”) .
From there, the compiler will automatically generate a piece of code like this:
1 2 3 4 5 6 | Class XYZ implements CarFilter { public boolean confirm(Car car) { return car.getProducer().equals(“Honda”); } } |
And so the program runs well !! Well, lambda is actually very simple, isn’t it