Lambda மற்றும் Functional Interfaces என்ன?

Question

Accepted Answer

**Lambda** (Java 8+) என்பது சுருக்கமான பெயரற்ற செயல்பாடுகள், மற்றும் **functional interface** என்பது **சரியாக ஒரு abstract method** கொண்ட ஒரு interface ஆகும் — lambda செயல்படுத்தும் target type. இவை இரண்டும் Java க்கு functional programming ஐ கொண்டு வந்தன மற்றும் Stream API இன் சக்தি. ## Functional Interface ```java @FunctionalInterface // optional annotation — enforces ONE abstract method interface Calculator { int calculate(int a, int b); // the single abstract method } ``` ஒரு abstract method கொண்ட interface "functional" ஆகும் — lambda அதை செயல்படுத்த முடியும் ஏனெனில் lambda எந்த method ஐ பிரதிநிதித்துவம் செய்கிறது என்பதில் எந்த சந்தேகமும் இல்லை. ## Lambda Syntax — இதை சுருக்கமாக செயல்படுத்தவும் ```java // ❌ 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 ``` Lambda `(a, b) -> a + b` ஒரே method இன் செயல்பாட்டை வழங்குகிறது — class இல்லை, method signature boilerplate இல்லை. ## Built-in Functional Interfaces (java.util.function) ```java Function length = s -> s.length(); // takes T, returns R Predicate isPositive = n -> n > 0; // takes T, returns boolean Consumer printer = s -> System.out.println(s); // takes T, returns void Supplier greeting = () -> "Hello"; // takes nothing, returns T BiFunction sum = (a, b) -> a + b; // two args ``` Java பொதுவான வடிவங்களுக்கு தயாரிக்கப்பட்ட functional interfaces ஐ வழங்குகிறது, முழு நிலையான library ல் (குறிப்பாக streams) பயன்படுத்தப்படுகிறது. ## Method References — இன்னும் குறுகியது ```java // 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 ``` ## Lambda களுவிரும் இடம் ```java // 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 ``` ## இது ஏன் முக்கியமாக உள்ளது Lambda மற்றும் functional interfaces Java க்கு functional programming ஐ கொண்டு வந்தன மற்றும் நவீன Java எப்படி எழுதப்படுகிறது என்பதை அடிப்படையாக மாற்றி விட்டன. அவை anonymous-class boilerplate ஐ **behavior as data** ஐ கடந்து செல்லுவதற்கு நீக்கி விடுகிறது, event handlers, comparators, callbacks மற்றும் — மிக முக்கியமாக — முழு **Stream API** (இது lambda களுக்கு filter/map/reduce operations க்கு சார்ந்துள்ளது) ஐ செயல்படுத்துவதற்கு ஒரு idiomatic நவீன Java எழுத வேண்டும் மற்றும் streams, collections, மற்றும் concurrent APIs ஐ திறம்பட பயன்படுத்த வேண்டும். அவை மொழியின் ஒரு பெரிய பரிணாமத்தைப் பிரதிநிதித்துவம் செய்கிறது மற்றும் தற்போதைய Java fluency இன் முக்கிய பகுதி.