લેમ્બડા (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 એક પદ્ધતિની અમલીકરણ આપે છે — કોઈ વર્ગ નથી, કોઈ પદ્ધતિ હસ્તાક્ષર boilerplate નથી.
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 સામાન્ય આકારો માટે તૈયાર-કરેલા કાર્યાત્મક ઇન્ટરફેસ પ્રદાન કરે છે, જેનો ઉપયોગ સંપૂર્ણ માનક લાઇબ્રેરીમાં થાય છે (ખાસ કરીને streams).
// 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 કેવી રીતે લખવામાં આવે છે તે મૌલિક રીતે બદલ્યું.
તેઓ વર્તણૂક ડેટા તરીકે પસાર કરવા માટે વર્બોસ અનામી-વર્ગ boilerplate નાબૂદ કરે છે, જે સંક્ષિપ્ત ઈવેન્ટ હેન્ડલર્સ, તુલનાકાર, કોલબેક્સ, અને — સૌથી જરૂરી — સમગ્ર Stream API (જે તેના filter/map/reduce કામગીરી માટે lambdas પર આધારિત છે) સક્ષમ કરે છે.
યह સમજવું આવશ્યક છે કે લેમ્બડા કાર્યાત્મક ઇન્ટરફેસ (એક અમૂર્ત પદ્ધતિ), બિલ્ટ-ઇન ઇન્ટરફેસ (Function, Predicate, Consumer, Supplier), અને પદ્ધતિ સંદર્ભ આધુનિક Java ને સ્વાભાવિક રીતે લખવા અને streams, સંગ્રહ, અને સમવર્તી APIs ને અસરકારક રીતે ઉપયોગ કરવા માટે આવશ્યક છે.
તેઓ ભાષાનું મુખ્ય વિકાસ પ્રતિનિધિત્વ કરે છે અને વર્તમાન Java કુશળતા માટે મુખ્ય છે.