ლამბდა (Java 8+) არის ლაკონური ანონიმური ფუნქციები, და ფუნქციონალური ინტერფეისი არის ინტერფეისი ზუსტად ერთი აბსტრაქტული მეთოდით — სამიზნე ტიპი, რომელიც ლამბდა ა護ს. ისინი ერთად მოიტანეს ფუნქციონალური პროგრამირება Java-ში და მართავენ Stream API-ს.
{
;
}
ინტერფეისი ერთი აბსტრაქტული მეთოდით არის "ფუნქციონალური" — ლამბდა შეუძლია მისი რეალიზება, რადგან არ არის ორაზობა იმის შესახებ, რომელი მეთოდი წარმოადგენს ლამბდა.
// ❌ verbose anonymous class (pre-Java 8)
Calculator add = new Calculator() {
public int calculate(int a, int b) { return a + b; }
};
// ✅ lambda — same thing, far less boilerplate
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
add.calculate(2, 3); // 5
ლამბდა (a, b) -> a + b აქვს ერთი მეთოდის რეალიზება — არა კლასი, არა მეთოდის ხელმოწერის ბურტია.
Function<String, Integer> length = s -> s.length(); // takes T, returns R
Predicate<Integer> isPositive = n -> n > 0; // takes T, returns boolean
Consumer<String> printer = s -> System.out.println(s); // takes T, returns void
Supplier<String> greeting = () -> "Hello"; // takes nothing, returns T
BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b; // two args
Java იძლევა მზა ფუნქციონალური ინტერფეისებს საერთო ფორმებისთვის, რომელიც გამოიყენება მთელი სტანდარტული ბიბლიოთეკაში (განსაკუთრებით stream-ებში).
// when a lambda just calls an existing method, use a method reference
list.forEach(System.out::println); // instead of x -> System.out.println(x)
list.stream().map(String::toUpperCase); // instead of s -> s.toUpperCase()
list.stream().map(Integer::parseInt); // static method ref
// passing behavior as arguments — the core enabler of the Stream API
people.stream()
.filter(p -> p.getAge() > 18) // Predicate lambda
.map(Person::getName) // method reference
.forEach(System.out::println); // Consumer
list.sort((a, b) -> a.compareTo(b)); // Comparator lambda
button.addActionListener(e -> handleClick()); // event handler
ლამბდა და ფუნქციონალური ინტერფეისები მოიტანეს ფუნქციონალური პროგრამირება Java-ში, რაც ფუნდამენტურად შეცვალა თანამედროვე Java-ს წერის მეთოდი.
ისინი აშორებენ ზედმეტი ანონიმური კლასების ბურთს ქცევის როგორც მონაცემები გადაწოდებისას, გაძლევთ შესაძლებლობას ლაკონური ღვე-დამკვირვებელი, შემადგენელი, საკრებული და — ყველაზე მნიშვნელოვანი — მთელი Stream API (რომელიც დამოკიდებულია ლამბდაზე filter/map/reduce ოპერაციებისთვის).
საჭიროა გაიგოთ, რომ ლამბდა სამიზნე ფუნქციონალური ინტერფეისი (ერთი აბსტრაქტული მეთოდი), ჩაშენებული ინტერფეისები (Function, Predicate, Consumer, Supplier) და მეთოდის მიმართულებები იდიომატური თანამედროვე Java-ს წერისა და stream-ებს, კოლექციებს და კონკურენტულ API-ებს ეფექტურად გამოყენების დროს.
ისინი წარმოადგენენ ენის მნიშვნელოვან ევოლუციას და ეს არის თანამედროვე Java-ს დაუფლების შინაარსი.