లాంబ్డా వ్యక్తీకరణలు

జావా 8 నుండి ప్రారంభించి, ఫంక్షనల్ ప్రోగ్రామింగ్ లాంబ్డా ఎక్స్‌ప్రెషన్స్ ద్వారా మద్దతు ఇస్తుంది. లాంబ్డా వ్యక్తీకరణ అనేది తప్పనిసరిగా అనామక పద్ధతి (పేరు లేని ఫంక్షన్), ఇది పద్ధతులకు వాదనగా పంపబడుతుంది లేదా వేరియబుల్స్‌లో నిల్వ చేయబడుతుంది.

ఫంక్షనల్ ఇంటర్‌ఫేస్‌లు

ఫంక్షనల్ ఇంటర్‌ఫేస్ అవసరమైన చోట మాత్రమే లాంబ్డా వ్యక్తీకరణ ఉపయోగించబడుతుంది. ఫంక్షనల్ ఇంటర్‌ఫేస్ అనేది ఖచ్చితంగా ఒక నైరూప్య పద్ధతిని ప్రకటించే ఇంటర్‌ఫేస్. జావా ఈ ఇంటర్‌ఫేస్‌లను ఐచ్ఛిక @FunctionalInterface ఉల్లేఖనతో గుర్తు చేస్తుంది.

వినియోగదారు నిర్వచించిన ఫంక్షనల్ ఇంటర్‌ఫేస్‌కి ఉదాహరణ:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

జావా 8కి ముందు, మీరు అనామక అంతర్గత తరగతిని నిర్వచించవలసి ఉంటుంది. లాంబ్డాస్‌తో, వాక్యనిర్మాణం ఇలా సరళీకృతం చేయబడింది:

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Returns 8

లాంబ్డా వ్యక్తీకరణల నిర్మాణం

లాంబ్డా యొక్క ప్రాథమిక వాక్యనిర్మాణం:

(parameters) -> { body }

• పరామితులు లేకుండా: () -> System.out.println("Hello")
• ఒకే పరామితి: x -> x * 2 (కుండలీకరణాలను విస్మరించవచ్చు)
• బహుళ పారామితులు: (x, y) -> x + y
• మల్టీ-లైన్ బాడీ: శరీరం బహుళ స్టేట్‌మెంట్‌లను కలిగి ఉంటే, {} కలుపులు మరియు స్పష్టమైన return స్టేట్‌మెంట్ అవసరం.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Adding...");
    return a + b;
};

జావాలో ప్రామాణిక ఫంక్షనల్ ఇంటర్‌ఫేస్‌లు

java.util.function ప్యాకేజీ అనేక అంతర్నిర్మిత ఫంక్షనల్ ఇంటర్‌ఫేస్‌లను అందిస్తుంది:

• Predicate<T>: T రకం ఆర్గ్యుమెంట్‌ని అంగీకరిస్తుంది మరియు బూలియన్ (test(T t) పద్ధతి)ని అందిస్తుంది.
• Consumer<T>: T రకం ఆర్గ్యుమెంట్‌ని అంగీకరిస్తుంది మరియు ఫలితాన్ని అందించకుండా ఆపరేషన్ చేస్తుంది (accept(T t) పద్ధతి).
• Function<T, R>: ఒక ఆర్గ్యుమెంట్‌ను అంగీకరిస్తుంది T మరియు ఫలితాన్ని అందిస్తుంది R (apply(T t) పద్ధతి).
• Supplier<T>: ఏ ఆర్గ్యుమెంట్‌లను అంగీకరించదు మరియు రకం T (get() పద్ధతి) విలువను అందిస్తుంది.

మీరే ప్రయత్నించండి