ஜாவாவில் லாம்ப்டா வெளிப்பாடுகளின் விளக்கம். எடுத்துக்காட்டுகள் மற்றும் பணிகளுடன். பகுதி 1

இந்தக் கட்டுரை யாருக்காக?

• தங்களுக்கு ஏற்கனவே ஜாவா கோர் நன்றாகத் தெரியும், ஆனால் ஜாவாவில் லாம்ப்டா வெளிப்பாடுகள் பற்றி எந்தத் தகவலும் இல்லை என்று நினைக்கும் நபர்களுக்கானது. அல்லது லாம்ப்டா வெளிப்பாடுகளைப் பற்றி அவர்கள் ஏதாவது கேள்விப்பட்டிருக்கலாம், ஆனால் விவரங்கள் குறைவாகவே உள்ளன
• இது லாம்ப்டா வெளிப்பாடுகளைப் பற்றி ஒரு குறிப்பிட்ட புரிதலைக் கொண்டவர்களுக்கானது.

இந்த வகைகளில் ஒன்று உங்களுக்குப் பொருந்தவில்லை எனில், இந்தக் கட்டுரை சலிப்பூட்டுவதாகவோ, குறைபாடுள்ளதாகவோ அல்லது பொதுவாக உங்கள் தேநீர் கோப்பையாகவோ இருக்காது. இந்தச் சந்தர்ப்பத்தில், மற்ற விஷயங்களுக்குச் செல்ல தயங்காதீர்கள் அல்லது நீங்கள் இந்த விஷயத்தில் நன்கு அறிந்தவராக இருந்தால், கட்டுரையை நான் எவ்வாறு மேம்படுத்தலாம் அல்லது கூடுதலாகச் சேர்க்கலாம் என்பது குறித்த கருத்துகளில் பரிந்துரைகளைச் செய்யுங்கள். புதுமை ஒருபுறம் இருக்க, பொருள் எந்த கல்வி மதிப்பையும் கொண்டிருக்கவில்லை. முற்றிலும் மாறாக: சிக்கலான விஷயங்களை (சிலருக்கு) முடிந்தவரை எளிமையாக விவரிக்க முயற்சிப்பேன். ஸ்ட்ரீம் ஏபிஐயை விளக்குவதற்கான கோரிக்கை இதை எழுத என்னைத் தூண்டியது. நான் அதைப் பற்றி யோசித்து, லாம்ப்டா வெளிப்பாடுகள் பற்றிய புரிதல் இல்லாமல் எனது சில ஸ்ட்ரீம் எடுத்துக்காட்டுகள் புரிந்துகொள்ள முடியாததாக இருக்கும் என்று முடிவு செய்தேன். எனவே நாம் லாம்ப்டா வெளிப்பாடுகளுடன் தொடங்குவோம். இந்தக் கட்டுரையைப் புரிந்துகொள்ள நீங்கள் தெரிந்து கொள்ள வேண்டியது என்ன?

1. பொருள் சார்ந்த நிரலாக்கத்தை (OOP) நீங்கள் புரிந்து கொள்ள வேண்டும், அதாவது:

   • வகுப்புகள், பொருள்கள் மற்றும் அவற்றுக்கிடையேயான வேறுபாடு;
   • இடைமுகங்கள், அவை வகுப்புகளிலிருந்து எவ்வாறு வேறுபடுகின்றன, இடைமுகங்கள் மற்றும் வகுப்புகளுக்கு இடையிலான உறவு;
   • முறைகள், அவற்றை எவ்வாறு அழைப்பது, சுருக்க முறைகள் (அதாவது செயல்படுத்தப்படாத முறைகள்), முறை அளவுருக்கள், முறை வாதங்கள் மற்றும் அவற்றை எவ்வாறு அனுப்புவது;
   • அணுகல் மாற்றிகள், நிலையான முறைகள்/மாறிகள், இறுதி முறைகள்/மாறிகள்;
   • வகுப்புகள் மற்றும் இடைமுகங்களின் பரம்பரை, இடைமுகங்களின் பல பரம்பரை.
2. ஜாவா கோர் பற்றிய அறிவு: பொதுவான வகைகள் (ஜெனரிக்ஸ்), சேகரிப்புகள் (பட்டியல்கள்), நூல்கள்.

சரி, அதற்கு வருவோம்.

ஒரு சிறிய வரலாறு

லாம்ப்டா வெளிப்பாடுகள் செயல்பாட்டு நிரலாக்கத்திலிருந்து ஜாவாவிற்கும், கணிதத்திலிருந்தும் வந்தன. 20 ஆம் நூற்றாண்டின் நடுப்பகுதியில் அமெரிக்காவில், கணிதம் மற்றும் அனைத்து வகையான சுருக்கங்களையும் மிகவும் விரும்பிய அலோன்சோ சர்ச், பிரின்ஸ்டன் பல்கலைக்கழகத்தில் பணிபுரிந்தார். அலோன்சோ சர்ச் தான் லாம்ப்டா கால்குலஸைக் கண்டுபிடித்தார், இது ஆரம்பத்தில் நிரலாக்கத்துடன் முற்றிலும் தொடர்பில்லாத சுருக்க யோசனைகளின் தொகுப்பாகும். ஆலன் டூரிங் மற்றும் ஜான் வான் நியூமன் போன்ற கணிதவியலாளர்கள் ஒரே நேரத்தில் பிரின்ஸ்டன் பல்கலைக்கழகத்தில் பணிபுரிந்தனர். எல்லாம் ஒன்றாக வந்தது: சர்ச் லாம்ப்டா கால்குலஸைக் கொண்டு வந்தது. டூரிங் தனது சுருக்க கணினி இயந்திரத்தை உருவாக்கினார், இது இப்போது "டூரிங் இயந்திரம்" என்று அழைக்கப்படுகிறது. வான் நியூமன் ஒரு கணினி கட்டமைப்பை முன்மொழிந்தார், இது நவீன கணினிகளின் அடிப்படையை உருவாக்கியது (தற்போது "வான் நியூமன் கட்டிடக்கலை" என்று அழைக்கப்படுகிறது). அந்த நேரத்தில், அலோன்சோ சர்ச்' வின் யோசனைகள் அவரது சக ஊழியர்களின் படைப்புகளாக அறியப்படவில்லை (தூய கணிதத் துறையைத் தவிர). இருப்பினும், சிறிது நேரம் கழித்து ஜான் மெக்கார்த்தி (பிரின்ஸ்டன் பல்கலைக்கழக பட்டதாரி மற்றும் எங்கள் கதையின் போது, ​​மாசசூசெட்ஸ் இன்ஸ்டிடியூட் ஆப் டெக்னாலஜியின் ஊழியர்) சர்ச்சின் கருத்துக்களில் ஆர்வம் காட்டினார். 1958 இல், அவர் அந்த யோசனைகளின் அடிப்படையில் முதல் செயல்பாட்டு நிரலாக்க மொழியான LISP ஐ உருவாக்கினார். 58 ஆண்டுகளுக்குப் பிறகு, ஜாவா 8 இல் செயல்பாட்டு நிரலாக்கத்தின் யோசனைகள் கசிந்தன. 70 ஆண்டுகள் கூட கடந்திருக்கவில்லை... உண்மையாகச் சொல்வதானால், நடைமுறையில் ஒரு கணித யோசனையைப் பயன்படுத்துவதற்கு இது மிக நீண்ட காலம் அல்ல. மாசசூசெட்ஸ் இன்ஸ்டிடியூட் ஆப் டெக்னாலஜி ஊழியர்) சர்ச்சின் கருத்துக்களில் ஆர்வம் காட்டினார். 1958 இல், அவர் அந்த யோசனைகளின் அடிப்படையில் முதல் செயல்பாட்டு நிரலாக்க மொழியான LISP ஐ உருவாக்கினார். 58 ஆண்டுகளுக்குப் பிறகு, ஜாவா 8 இல் செயல்பாட்டு நிரலாக்கத்தின் யோசனைகள் கசிந்தன. 70 ஆண்டுகள் கூட கடந்திருக்கவில்லை... உண்மையாகச் சொல்வதானால், நடைமுறையில் ஒரு கணித யோசனையைப் பயன்படுத்துவதற்கு இது மிக நீண்ட காலம் அல்ல. மாசசூசெட்ஸ் இன்ஸ்டிடியூட் ஆப் டெக்னாலஜி ஊழியர்) சர்ச்சின் கருத்துக்களில் ஆர்வம் காட்டினார். 1958 இல், அவர் அந்த யோசனைகளின் அடிப்படையில் முதல் செயல்பாட்டு நிரலாக்க மொழியான LISP ஐ உருவாக்கினார். 58 ஆண்டுகளுக்குப் பிறகு, ஜாவா 8 இல் செயல்பாட்டு நிரலாக்கத்தின் யோசனைகள் கசிந்தன. 70 ஆண்டுகள் கூட கடந்திருக்கவில்லை... உண்மையாகச் சொல்வதானால், நடைமுறையில் ஒரு கணித யோசனையைப் பயன்படுத்துவதற்கு இது மிக நீண்ட காலம் அல்ல.

விஷயத்தின் இதயம்

லாம்ப்டா வெளிப்பாடு என்பது ஒரு வகையான செயல்பாடு. நீங்கள் அதை ஒரு சாதாரண ஜாவா முறையாகக் கருதலாம், ஆனால் ஒரு வாதமாக மற்ற முறைகளுக்கு அனுப்பப்படும் தனித்துவமான திறனுடன். அது சரி. எண்கள், சரங்கள் மற்றும் பூனைகளை முறைகளுக்கு மட்டுமல்ல, பிற முறைகளையும் அனுப்புவது சாத்தியமாகிவிட்டது! நமக்கு இது எப்போது தேவைப்படலாம்? எடுத்துக்காட்டாக, சில கால்பேக் முறையை அனுப்ப விரும்பினால் அது உதவியாக இருக்கும். அதாவது, நாம் அழைக்கும் முறை தேவைப்பட்டால், அதற்கு நாம் அனுப்பும் வேறு சில முறைகளை அழைக்கும் திறன் உள்ளது. வேறு வார்த்தைகளில் கூறுவதானால், சில சூழ்நிலைகளில் ஒரு அழைப்பை அனுப்பும் திறன் மற்றும் மற்றவற்றில் வேறுபட்ட அழைப்பை அனுப்பும் திறன் எங்களிடம் உள்ளது. அதனால் எங்கள் அழைப்புகளைப் பெறும் எங்கள் முறை அவர்களை அழைக்கிறது. வரிசைப்படுத்துதல் ஒரு எளிய உதாரணம். இது போன்ற சில புத்திசாலித்தனமான வரிசையாக்க வழிமுறையை எழுதுகிறோம் என்று வைத்துக்கொள்வோம்:

public void mySuperSort() { 
    // We do something here 
    if(compare(obj1, obj2) > 0) 
    // And then we do something here 
}

அறிக்கையில் if, ஒப்பிட வேண்டிய இரண்டு பொருட்களைக் கடந்து செல்லும் முறையை நாங்கள் அழைக்கிறோம் compare(), மேலும் இந்த பொருள்களில் எது "பெரியது" என்பதை அறிய விரும்புகிறோம். "பெரிய" ஒன்று "குறைவான" ஒன்றிற்கு முன் வரும் என்று கருதுகிறோம். நான் மேற்கோள்களில் "பெரிய" என்று வைத்தேன், ஏனென்றால் நாங்கள் ஒரு உலகளாவிய முறையை எழுதுகிறோம், அது ஏறுவரிசையில் மட்டுமல்ல, இறங்கு வரிசையிலும் எப்படி வரிசைப்படுத்துவது என்பதை அறியும் (இந்த விஷயத்தில், "பெரிய" பொருள் உண்மையில் "குறைவான" பொருளாக இருக்கும். , மற்றும் நேர்மாறாகவும்). எங்கள் வகைக்கான குறிப்பிட்ட அல்காரிதத்தை அமைக்க, அதை எங்கள் முறைக்கு அனுப்ப சில வழிமுறைகள் தேவை mySuperSort(). அதன் மூலம் நமது முறை அழைக்கப்படும் போது அதை "கட்டுப்படுத்த" முடியும். நிச்சயமாக, நாம் இரண்டு தனித்தனி முறைகளை எழுதலாம் - mySuperSortAscend()மற்றும்mySuperSortDescend()- ஏறுவரிசை மற்றும் இறங்கு வரிசையில் வரிசைப்படுத்த. அல்லது நாம் சில வாதங்களை முறைக்கு அனுப்பலாம் (உதாரணமாக, ஒரு பூலியன் மாறி; உண்மை என்றால், ஏறுவரிசையில் வரிசைப்படுத்தவும், தவறு என்றால், இறங்கு வரிசையில்). ஆனால் சரம் வரிசைகளின் பட்டியல் போன்ற சிக்கலான ஒன்றை நாம் வரிசைப்படுத்த விரும்பினால் என்ன செய்வது? mySuperSort()இந்த சரம் வரிசைகளை எப்படி வரிசைப்படுத்துவது என்பதை எங்கள் முறை எப்படி அறியும்? அளவு மூலம்? அனைத்து வார்த்தைகளின் மொத்த நீளத்தின் மூலம்? அணிவரிசையில் முதல் சரத்தின் அடிப்படையில் அகரவரிசைப்படி இருக்கலாம்? வரிசைகளின் பட்டியலை சில சமயங்களில் வரிசை அளவிலும், மற்ற சமயங்களில் ஒவ்வொரு வரிசையில் உள்ள அனைத்து சொற்களின் ஒட்டுமொத்த நீளத்திலும் வரிசைப்படுத்த வேண்டும் என்றால் என்ன செய்வது? ஒப்பீட்டாளர்களைப் பற்றி நீங்கள் ஏற்கனவே கேள்விப்பட்டிருப்பீர்கள் என்று நான் எதிர்பார்க்கிறேன். ஏனெனில் தரநிலைsort()இந்த முறை அதே கொள்கையின் அடிப்படையில் செயல்படுத்தப்படுகிறது , நான் எனது எடுத்துக்காட்டுகளில் mySuperSort()பயன்படுத்துவேன் .sort()

String[] array1 = {"Dota", "GTA5", "Halo"}; 
String[] array2 = {"I", "really", "love", "Java"}; 
String[] array3 = {"if", "then", "else"}; 

List<String[]> arrays = new ArrayList<>(); 
arrays.add(array1); 
arrays.add(array2); 
arrays.add(array3); 

Comparator<;String[]> sortByLength = new Comparator<String[]>() { 
    @Override 
    public int compare(String[] o1, String[] o2) { 
        return o1.length - o2.length; 
    } 
}; 

Comparator<String[]> sortByCumulativeWordLength = new Comparator<String[]>() { 

    @Override 
    public int compare(String[] o1, String[] o2) { 
        int length1 = 0; 
        int length2 = 0; 
        for (String s : o1) { 
            length1 += s.length(); 
        } 

        for (String s : o2) { 
            length2 += s.length(); 
        } 

        return length1 - length2; 
    } 
};

arrays.sort(sortByLength);

விளைவாக:

Dota GTA5 Halo
if then else
I really love Java

இங்கே வரிசைகள் ஒவ்வொரு அணியிலும் உள்ள சொற்களின் எண்ணிக்கையால் வரிசைப்படுத்தப்படுகின்றன. குறைவான சொற்களைக் கொண்ட வரிசை "குறைவானதாக" கருதப்படுகிறது. அதனால்தான் முதலில் வருகிறது. அதிக சொற்களைக் கொண்ட வரிசை "பெரியது" எனக் கருதப்பட்டு இறுதியில் வைக்கப்படும். முறைக்கு வேறு ஒப்பீட்டாளரைக் கடந்து சென்றால் sort(), எடுத்துக்காட்டாக sortByCumulativeWordLength, வேறு முடிவைப் பெறுவோம்:

if then else
Dota GTA5 Halo
I really love Java

இப்போது are வரிசைகள் வரிசையின் சொற்களில் உள்ள மொத்த எழுத்துக்களின் எண்ணிக்கையால் வரிசைப்படுத்தப்படுகின்றன. முதல் வரிசையில், 10 எழுத்துக்கள் உள்ளன, இரண்டாவது - 12, மற்றும் மூன்றாவது - 15. நம்மிடம் ஒரே ஒரு ஒப்பீட்டாளர் இருந்தால், அதற்கு ஒரு தனி மாறியை அறிவிக்க வேண்டியதில்லை. அதற்குப் பதிலாக, முறைக்கு அழைக்கும் நேரத்தில் ஒரு அநாமதேய வகுப்பை உருவாக்கலாம் sort(). இந்த மாதிரி ஏதாவது:

String[] array1 = {"Dota", "GTA5", "Halo"}; 
String[] array2 = {"I", "really", "love", "Java"}; 
String[] array3 = {"if", "then", "else"}; 

List<String[]> arrays = new ArrayList<>(); 

arrays.add(array1); 
arrays.add(array2); 
arrays.add(array3); 

arrays.sort(new Comparator<String[]>() { 
    @Override 
    public int compare(String[] o1, String[] o2) { 
        return o1.length - o2.length; 
    } 
}); 

முதல் வழக்கில் இருந்த அதே முடிவைப் பெறுவோம்.   பணி 1. இந்த எடுத்துக்காட்டை மீண்டும் எழுதவும், இதனால் அது வரிசைகளை ஒவ்வொரு வரிசையில் உள்ள சொற்களின் எண்ணிக்கையின் ஏறுவரிசையில் அல்ல, ஆனால் இறங்கு வரிசையில் வரிசைப்படுத்துகிறது. இதெல்லாம் நமக்கு முன்பே தெரியும். பொருட்களை எவ்வாறு முறைகளுக்கு அனுப்புவது என்பது எங்களுக்குத் தெரியும். இந்த நேரத்தில் நமக்கு என்ன தேவை என்பதைப் பொறுத்து, வெவ்வேறு பொருட்களை ஒரு முறைக்கு அனுப்பலாம், அது நாம் செயல்படுத்திய முறையைத் தொடங்கும். இது கேள்வியைக் கேட்கிறது: உலகில் ஏன் இங்கு ஒரு லாம்ப்டா வெளிப்பாடு தேவை?  ஏனெனில் ஒரு லாம்ப்டா வெளிப்பாடு என்பது ஒரு பொருளைக் கொண்ட ஒரு பொருளைக் கொண்டுள்ளது. ஒரு "முறை பொருள்" போல. ஒரு பொருளில் தொகுக்கப்பட்ட ஒரு முறை. இது சற்று அறிமுகமில்லாத தொடரியலைக் கொண்டுள்ளது (ஆனால் பின்னர் அதைப் பற்றி மேலும்). இந்த குறியீட்டை மீண்டும் பார்ப்போம்:

arrays.sort(new Comparator<String[]>() { 
    @Override 
    public int compare(String[] o1, String[] o2) { 
        return o1.length - o2.length; 
    } 
});

இங்கே நாம் எங்கள் அணிவரிசைகளின் பட்டியலை எடுத்து அதன் sort()முறையை அழைக்கிறோம், அதற்கு ஒரு ஒப்பீட்டு பொருளை ஒரு முறை மூலம் அனுப்புகிறோம் compare()(அதன் பெயர் எங்களுக்கு ஒரு பொருட்டல்ல - எல்லாவற்றிற்கும் மேலாக, இது பொருளின் ஒரே முறை, எனவே நாங்கள் தவறாகப் போக முடியாது). இந்த முறை இரண்டு அளவுருக்களைக் கொண்டுள்ளது, அதை நாங்கள் வேலை செய்வோம். நீங்கள் IntelliJ IDEA இல் பணிபுரிகிறீர்கள் என்றால், பின்வருவனவற்றில் குறியீட்டை குறிப்பிடத்தக்க அளவில் சுருக்கி வழங்குவதை நீங்கள் பார்த்திருக்கலாம்:

arrays.sort((o1, o2) -> o1.length - o2.length);

இது ஆறு வரிகளை ஒரு சிறிய வரியாக குறைக்கிறது. 6 வரிகள் ஒரு சிறிய வரியாக மீண்டும் எழுதப்பட்டுள்ளன. ஏதோ மறைந்து விட்டது, ஆனால் அது முக்கியமான ஒன்று இல்லை என்று நான் உறுதியளிக்கிறேன். இந்த குறியீடு ஒரு அநாமதேய வகுப்பைப் போலவே செயல்படும். டாஸ்க் 2. லாம்ப்டா எக்ஸ்ப்ரெஷனைப் பயன்படுத்தி டாஸ்க் 1 க்கு தீர்வை மீண்டும் எழுதுவது பற்றி யூகிக்கவும் (குறைந்தபட்சம், உங்கள் அநாமதேய வகுப்பை லாம்ப்டா எக்ஸ்பிரஷனாக மாற்ற IntelliJ IDEA ஐக் கேளுங்கள்).

இடைமுகங்களைப் பற்றி பேசலாம்

கொள்கையளவில், ஒரு இடைமுகம் என்பது சுருக்க முறைகளின் பட்டியல். சில இடைமுகங்களைச் செயல்படுத்தும் வகுப்பை உருவாக்கும்போது, ​​இடைமுகத்தில் உள்ள முறைகளை எங்கள் வகுப்பு செயல்படுத்த வேண்டும் (அல்லது வகுப்பை சுருக்கமாக மாற்ற வேண்டும்). பல்வேறு முறைகளைக் கொண்ட இடைமுகங்கள் உள்ளன (உதாரணமாக,  List), மற்றும் ஒரே ஒரு முறையுடன் இடைமுகங்கள் உள்ளன (எடுத்துக்காட்டாக, Comparatorஅல்லது Runnable). ஒற்றை முறை இல்லாத இடைமுகங்கள் உள்ளன (மார்க்கர் இடைமுகங்கள் என அழைக்கப்படும் Serializable). ஒரே ஒரு முறையைக் கொண்ட இடைமுகங்கள் செயல்பாட்டு இடைமுகங்கள் என்றும் அழைக்கப்படுகின்றன . ஜாவா 8 இல், அவை ஒரு சிறப்பு சிறுகுறிப்புடன் கூட குறிக்கப்பட்டுள்ளன:@FunctionalInterface. இந்த ஒற்றை முறை இடைமுகங்களே லாம்ப்டா வெளிப்பாடுகளுக்கு இலக்கு வகைகளாகப் பொருத்தமானவை. நான் மேலே கூறியது போல், ஒரு லாம்ப்டா வெளிப்பாடு என்பது ஒரு பொருளில் மூடப்பட்ட ஒரு முறையாகும். அத்தகைய ஒரு பொருளை நாம் கடந்து செல்லும் போது, ​​நாம் அடிப்படையில் இந்த ஒற்றை முறையை கடந்து செல்கிறோம். முறை என்ன அழைக்கப்படுகிறது என்பதை நாங்கள் பொருட்படுத்தவில்லை என்று மாறிவிடும். முறை அளவுருக்கள் மற்றும், நிச்சயமாக, முறையின் உடல் மட்டுமே எங்களுக்கு முக்கியம். சாராம்சத்தில், ஒரு லாம்ப்டா வெளிப்பாடு என்பது ஒரு செயல்பாட்டு இடைமுகத்தை செயல்படுத்துவதாகும். ஒற்றை முறையுடன் ஒரு இடைமுகத்தை எங்கு பார்த்தாலும், ஒரு அநாமதேய வகுப்பை லாம்ப்டாவாக மீண்டும் எழுதலாம். இடைமுகம் ஒன்றுக்கு மேற்பட்ட அல்லது குறைவான முறைகளைக் கொண்டிருந்தால், ஒரு லாம்ப்டா வெளிப்பாடு வேலை செய்யாது, அதற்குப் பதிலாக அநாமதேய வகுப்பை அல்லது சாதாரண வகுப்பின் உதாரணத்தைப் பயன்படுத்துவோம். இப்போது லாம்ப்டாக்களை கொஞ்சம் தோண்டி எடுக்க வேண்டிய நேரம் வந்துவிட்டது. :)

தொடரியல்

பொதுவான தொடரியல் இது போன்றது:

(parameters) -> {method body}

அதாவது, முறை அளவுருக்களைச் சுற்றியுள்ள அடைப்புக்குறிகள், ஒரு "அம்பு" (ஹைபன் மற்றும் பெரிய-அடையாளத்தால் உருவாக்கப்பட்டது), பின்னர் பிரேஸ்களில் முறை உடல், எப்போதும் போல. அளவுருக்கள் இடைமுக முறையில் குறிப்பிடப்பட்டவற்றுடன் ஒத்திருக்கும். மாறி வகைகளை கம்பைலரால் சந்தேகத்திற்கு இடமின்றி தீர்மானிக்க முடியும் என்றால் (எங்கள் விஷயத்தில், நாங்கள் சரம் வரிசைகளுடன் வேலை செய்கிறோம் என்று அது அறிந்திருக்கிறது, ஏனெனில் எங்கள் Listபொருள் ] ஐப் பயன்படுத்தி தட்டச்சு செய்யப்பட்டுள்ளது String[), அதன் வகைகளை நீங்கள் குறிப்பிட வேண்டியதில்லை. இந்த Oracle டுடோரியலிலும் மற்ற இடங்களிலும் நீங்கள் மேலும் படிக்கலாம் . இது " இலக்கு தட்டச்சு " என்று அழைக்கப்படுகிறது . நீங்கள் விரும்பும் மாறிகளுக்கு நீங்கள் பெயரிடலாம் - இடைமுகத்தில் குறிப்பிடப்பட்டுள்ள அதே பெயர்களை நீங்கள் பயன்படுத்த வேண்டியதில்லை. அளவுருக்கள் இல்லை என்றால், வெற்று அடைப்புக்குறிகளைக் குறிப்பிடவும். ஒரே ஒரு அளவுரு இருந்தால், எந்த அடைப்புக்குறிகளும் இல்லாமல் மாறி பெயரைக் குறிப்பிடவும். இப்போது நாம் அளவுருக்களைப் புரிந்துகொள்கிறோம், லாம்ப்டா வெளிப்பாட்டின் உடலைப் பற்றி விவாதிக்க வேண்டிய நேரம் இது. சுருள் பிரேஸ்களுக்குள், நீங்கள் ஒரு சாதாரண முறைக்கு எழுதுவது போல் குறியீட்டை எழுதுகிறீர்கள். உங்கள் குறியீடு ஒற்றை வரியைக் கொண்டிருந்தால், நீங்கள் சுருள் பிரேஸ்களை முழுவதுமாகத் தவிர்க்கலாம் (if-statements மற்றும் for-loops போன்றவை). உங்கள் ஒற்றை-வரி லாம்ப்டா ஏதாவது திரும்பினால், நீங்கள் சேர்க்க வேண்டியதில்லைreturnஅறிக்கை. ஆனால் நீங்கள் சுருள் பிரேஸ்களைப் பயன்படுத்தினால், நீங்கள் returnஒரு சாதாரண முறையைப் போலவே வெளிப்படையாக ஒரு அறிக்கையைச் சேர்க்க வேண்டும்.

எடுத்துக்காட்டுகள்

எடுத்துக்காட்டு 1.

() -> {}

எளிமையான உதாரணம். மற்றும் மிகவும் அர்த்தமற்றது :), அது எதையும் செய்யாது என்பதால். உதாரணம் 2.

() -> ""

மற்றொரு சுவாரஸ்யமான உதாரணம். இது எதுவும் எடுக்கவில்லை மற்றும் ஒரு வெற்று சரத்தை வழங்குகிறது ( returnதவிர்க்கப்பட்டது, ஏனெனில் இது தேவையற்றது). இங்கே அதே விஷயம், ஆனால் இதனுடன் return:

() -> { 
    return ""; 
}

எடுத்துக்காட்டு 3. "வணக்கம், உலகம்!" lambdas பயன்படுத்தி

() -> System.out.println("Hello, World!")

returnஇது எதுவும் எடுக்காது மற்றும் எதையும் திரும்பப் பெறாது ( அழைப்புக்கு முன் எங்களால் வைக்க முடியாது System.out.println(), ஏனெனில் println()முறை திரும்பும் வகை void). இது வெறுமனே வாழ்த்துக்களைக் காட்டுகிறது. இடைமுகத்தை செயல்படுத்த இது சிறந்தது Runnable. பின்வரும் எடுத்துக்காட்டு இன்னும் முழுமையானது:

public class Main { 
    public static void main(String[] args) { 
        new Thread(() -> System.out.println("Hello, World!")).start(); 
    } 
}

அல்லது இப்படி:

public class Main { 
    public static void main(String[] args) { 
        Thread t = new Thread(() -> System.out.println("Hello, World!")); 
        t.start();
    } 
}

அல்லது லாம்ப்டா வெளிப்பாட்டை ஒரு பொருளாகச் சேமித்து Runnable, அதை கட்டமைப்பாளரிடம் அனுப்பலாம் Thread:

public class Main { 
    public static void main(String[] args) { 
        Runnable runnable = () -> System.out.println("Hello, World!"); 
        Thread t = new Thread(runnable); 
        t.start(); 
    } 
}

ஒரு லாம்ப்டா வெளிப்பாடு ஒரு மாறியில் சேமிக்கப்படும் தருணத்தை கூர்ந்து கவனிப்போம். அதன் பொருள்களுக்கு ஒரு முறை இருக்க வேண்டும் என்று இடைமுகம் Runnableசொல்கிறது public void run(). இடைமுகத்தின் படி, runமுறை எந்த அளவுருக்களையும் எடுக்காது. மேலும் அது எதையும் திருப்பித் தருவதில்லை, அதாவது அதன் திரும்பும் வகை void. அதன்படி, இந்த குறியீடு எதையும் எடுக்காத அல்லது திரும்பப் பெறாத ஒரு பொருளை உருவாக்கும். இது Runnableஇடைமுகத்தின் run()முறையுடன் சரியாகப் பொருந்துகிறது. அதனால்தான் இந்த லாம்ப்டா எக்ஸ்ப்ரெஷனை ஒரு மாறியில் வைக்க முடிந்தது Runnable.  எடுத்துக்காட்டு 4.

() -> 42

மீண்டும், இது எதுவும் எடுக்காது, ஆனால் அது 42 என்ற எண்ணை வழங்குகிறது. அத்தகைய லாம்ப்டா வெளிப்பாட்டை ஒரு மாறியில் வைக்கலாம் Callable, ஏனெனில் இந்த இடைமுகத்தில் ஒரே ஒரு முறை மட்டுமே உள்ளது.

V call(),

திரும்பும் வகை எங்கே  V (எங்கள் விஷயத்தில்,  int). அதன்படி, லாம்ப்டா வெளிப்பாட்டை பின்வருமாறு சேமிக்கலாம்:

Callable<Integer> c = () -> 42;

எடுத்துக்காட்டு 5. பல வரிகளை உள்ளடக்கிய லாம்ப்டா வெளிப்பாடு

() -> { 
    String[] helloWorld = {"Hello", "World!"}; 
    System.out.println(helloWorld[0]); 
    System.out.println(helloWorld[1]); 
}

மீண்டும், இது அளவுருக்கள் இல்லாத லாம்ப்டா வெளிப்பாடு மற்றும் voidதிரும்பும் வகை (அறிக்கை இல்லாததால் return).  எடுத்துக்காட்டு 6

x -> x

இங்கே நாம் ஒரு xமாறியை எடுத்து அதை திரும்பப் பெறுகிறோம். ஒரே ஒரு அளவுரு இருந்தால், அதைச் சுற்றியுள்ள அடைப்புக்குறிகளைத் தவிர்க்கலாம். இங்கே அதே விஷயம், ஆனால் அடைப்புக்குறிக்குள்:

(x) -> x

வெளிப்படையான அறிக்கையுடன் கூடிய உதாரணம் இங்கே:

x -> { 
    return x;
}

அல்லது அடைப்புக்குறிகள் மற்றும் திரும்ப அறிக்கையுடன் இப்படி:

(x) -> { 
    return x;
}

அல்லது வகையின் வெளிப்படையான குறிப்புடன் (இதனால் அடைப்புக்குறிக்குள்):

(int x) -> x

எடுத்துக்காட்டு 7

x -> ++x

நாங்கள் xஅதை எடுத்து திருப்பித் தருகிறோம், ஆனால் 1ஐச் சேர்த்த பிறகுதான். அந்த லாம்ப்டாவை இப்படி மாற்றி எழுதலாம்:

x -> x + 1

returnஇரண்டு சந்தர்ப்பங்களிலும், அளவுரு மற்றும் முறை அமைப்பைச் சுற்றியுள்ள அடைப்புக்குறிகளை அறிக்கையுடன் சேர்த்து, அவை விருப்பமானவை என்பதால் அவற்றைத் தவிர்க்கிறோம் . அடைப்புக்குறிகளுடன் கூடிய பதிப்புகள் மற்றும் அறிக்கை அறிக்கை எடுத்துக்காட்டு 6. எடுத்துக்காட்டு 8 இல் கொடுக்கப்பட்டுள்ளன

(x, y) -> x % y

xஆல் வகுத்தலின் yமீதியை எடுத்து , திருப்பித் தருகிறோம் . அளவுருக்களைச் சுற்றி அடைப்புக்குறிகள் இங்கே தேவை. ஒரே ஒரு அளவுரு இருக்கும் போது மட்டுமே அவை விருப்பமாக இருக்கும். இங்கே இது வகைகளின் வெளிப்படையான குறிப்புடன் உள்ளது: xy

(double x, int y) -> x % y

எடுத்துக்காட்டு 9

(Cat cat, String name, int age) -> {
    cat.setName(name); 
    cat.setAge(age); 
}

நாம் ஒரு Catபொருள், ஒரு Stringபெயர் மற்றும் ஒரு முழு வயது. முறையிலேயே, பூனையின் மீது மாறிகளை அமைக்க, கடந்து வந்த பெயர் மற்றும் வயதைப் பயன்படுத்துகிறோம். எங்கள் catபொருள் ஒரு குறிப்பு வகை என்பதால், அது லாம்ப்டா வெளிப்பாட்டிற்கு வெளியே மாற்றப்படும் (அது கடந்த பெயரையும் வயதையும் பெறும்). இதேபோன்ற லாம்ப்டாவைப் பயன்படுத்தும் சற்று சிக்கலான பதிப்பு இங்கே:

public class Main { 

    public static void main(String[] args) { 
        // Create a cat and display it to confirm that it is "empty" 
        Cat myCat = new Cat(); 
        System.out.println(myCat);
 
        // Create a lambda 
        Settable<Cat> s = (obj, name, age) -> { 
            obj.setName(name); 
            obj.setAge(age); 

        }; 

        // Call a method to which we pass the cat and lambda 
        changeEntity(myCat, s); 

        // Display the cat on the screen and see that its state has changed (it has a name and age) 
        System.out.println(myCat); 

    } 

    private static <T extends HasNameAndAge>  void changeEntity(T entity, Settable<T> s) { 
        s.set(entity, "Smokey", 3); 
    }
}

interface HasNameAndAge { 
    void setName(String name); 
    void setAge(int age); 
}

interface Settable<C extends HasNameAndAge> { 
    void set(C entity, String name, int age); 
}

class Cat implements HasNameAndAge { 
    private String name; 
    private int age; 

    @Override 
    public void setName(String name) { 
        this.name = name;
    }

    @Override
    public void setAge(int age) {
        this.age = age; 
    } 

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' + 
                ", age=" + age + 
                '}';
    }
}

விளைவாக:

Cat{name='null', age=0}
Cat{name='Smokey', age=3}

நீங்கள் பார்க்க முடியும் என, Catபொருளுக்கு ஒரு நிலை இருந்தது, பின்னர் நாங்கள் லாம்ப்டா வெளிப்பாட்டைப் பயன்படுத்திய பிறகு நிலை மாறியது. லாம்ப்டா வெளிப்பாடுகள் ஜெனரிக்ஸுடன் முழுமையாக இணைகின்றன. Dogமேலும் செயல்படுத்தும் ஒரு வகுப்பை நாம் உருவாக்க வேண்டும் என்றால் ,  லாம்ப்டா வெளிப்பாட்டை மாற்றாமல் அதே செயல்பாடுகளை முறையிலும் HasNameAndAgeசெய்யலாம் . பணி 3. எண்ணை எடுத்து பூலியன் மதிப்பை வழங்கும் முறையுடன் செயல்பாட்டு இடைமுகத்தை எழுதவும். அனுப்பப்பட்ட எண்ணை 13 ஆல் வகுத்தால் உண்மை என்று வழங்கும் லாம்ப்டா வெளிப்பாடு போன்ற ஒரு இடைமுகத்தின் செயலாக்கத்தை எழுதவும். பணி 4.Dogmain()இரண்டு சரங்களை எடுத்து ஒரு சரத்தை வழங்கும் முறையுடன் செயல்பாட்டு இடைமுகத்தை எழுதவும். நீண்ட சரத்தை வழங்கும் லாம்ப்டா வெளிப்பாடு போன்ற இடைமுகத்தின் செயலாக்கத்தை எழுதவும். பணி 5. மூன்று மிதக்கும்-புள்ளி எண்களை எடுக்கும் முறையுடன் செயல்பாட்டு இடைமுகத்தை எழுதவும்: a, b மற்றும் c மற்றும் மிதக்கும் புள்ளி எண்ணையும் வழங்குகிறது. பாரபட்சத்தை வழங்கும் லாம்ப்டா வெளிப்பாடு போன்ற இடைமுகத்தை செயல்படுத்துவதை எழுதவும். நீங்கள் மறந்துவிட்டால், அது D = b^2 — 4ac. பணி 6. பணி 5 இலிருந்து செயல்பாட்டு இடைமுகத்தைப் பயன்படுத்தி, ஒரு லாம்ப்டா வெளிப்பாட்டை எழுதவும், அது முடிவை வழங்கும் a * b^c. ஜாவாவில் லாம்ப்டா வெளிப்பாடுகளின் விளக்கம். எடுத்துக்காட்டுகள் மற்றும் பணிகளுடன். பகுதி 2