ஜாவாவில், ' நுகர்வோர் 'இடைமுகம் என்பது ஒரு செயல்பாட்டைப் பிரதிநிதித்துவப்படுத்துகிறது, இது ஒரு உள்ளீட்டைப் பெறுகிறது மற்றும் முடிவைத் தராமல் சில செயல்களைச் செய்கிறது. லாம்ப்டா வெளிப்பாடுகள் போன்ற செயல்பாட்டு நிரலாக்கத்தில் பயன்படுத்தக்கூடிய தனிப்பயன் செயல்பாடுகளை வரையறுக்க இது ஒரு நெகிழ்வான வழியை வழங்குகிறது. இந்த வலைப்பதிவு ஜாவாவில் நுகர்வோர் இடைமுகத்தை செயல்படுத்துவதை விளக்குகிறது.
ஜாவாவில் நுகர்வோர் இடைமுகத்தை எவ்வாறு பயன்படுத்துவது?
' நுகர்வோர் ” இன்டர்ஃபேஸ் ஆனது இணைத்தல் அல்லது நடத்தையை வழங்குகிறது, இது நிரலின் வெவ்வேறு இடங்களில் சுற்றி அனுப்பப்பட்டு செயல்படுத்தப்படுகிறது. குறியீட்டை நகலெடுக்காமல் வெவ்வேறு உள்ளீடுகளுக்குப் பயன்படுத்தக்கூடிய மறுபயன்பாட்டு நடத்தையை இது ஊக்குவிக்கிறது. நுகர்வோர் இடைமுகம் இரண்டு முறைகளைக் கொண்டுள்ளது ' பின்னர் () 'மற்றும்' ஏற்றுக்கொள்() ”.
கோடெக் எடுத்துக்காட்டுகளுடன் இரண்டு செயல்பாடுகளையும் புரிந்து கொள்ள கீழே உள்ள எடுத்துக்காட்டுகளைப் பார்வையிடவும்:
எடுத்துக்காட்டு 1: “andThen()” முறையின் பயன்பாடு
டெவலப்பர் பல சங்கிலிகளை இணைக்க முடியும் ' நுகர்வோர் 'செயல்பாடுகள் முழுவதுமாக' பயன்படுத்துவதன் மூலம் பின்னர் () ”முறை. இது புதியதைத் தருகிறது' நுகர்வோர் 'இது மின்னோட்டத்தின் செயல்பாட்டைச் செய்கிறது' நுகர்வோர் 'உதாரணம். அதன் பிறகு, வரவிருக்கும்/பின்னர் செயல்பாடுகளை நிறைவேற்றுகிறது. நுகர்வோர் 'உதாரணம். இது 'செயல்முறைக்கு பரவலாகப் பயன்படுத்தப்படும் இயல்புநிலை முறையாகும். கலவை ”.
'க்கான தொடரியல் பின்னர் () 'முறை கீழே செருகப்பட்டுள்ளது:
பின்னர் ( நுகர்வோர் < ? சூப்பர் டி > பிறகு )
' பின்னர் () 'முறை தற்போதைய நுகர்வோரை ஒருங்கிணைக்கிறது' அருமை 'மற்றொரு நுகர்வோருடன்' பிறகு ”. மேலும் இது தற்போதைய நுகர்வோரின் செயல்பாட்டை முதலில் செயல்படுத்துகிறது, அதைத் தொடர்ந்து வழங்கப்பட்ட நுகர்வோரின் செயல்பாட்டை செயல்படுத்துகிறது.
ஒரு சிறந்த புரிதலுக்காக ஒரு நிரல் மூலம் நடப்போம்:
java.util.ArrayList இறக்குமதி;java.util.LinkedList இறக்குமதி;
java.util.List இறக்குமதி;
இறக்குமதி java.util.function.Consumer;
பொது வர்க்க ரூட் {
பொது நிலையான வெற்றிட முக்கிய ( சரம் ஆர்க்ஸ் [ ] )
{
// முக்கிய முறையை உருவாக்குதல்
நுகர்வோர் < பட்டியல் < முழு > > பெருக்கு = dataEle - >
{
க்கான ( int j = 0 ; ஜே < dataEle.size ( ) ; j++ ) {
dataEle.set ( j, 5 * dataEle.get ( ஜே ) ) ;
}
} ;
// முழு எண்களின் பட்டியலைக் காண்பிக்க நுகர்வோர்
நுகர்வோர் < பட்டியல் < முழு > >
அச்சுகள் = dataEle - > dataEle.stream ( ) .ஒவ்வொரு ( k - > System.out.print ( k + '' ) ) ;
பட்டியல் < முழு > dataEle = புதிய ArrayList < முழு > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
பெருக்கவும்.பின்னர் ( அச்சிடுகிறது ) .ஏற்றுக்கொள்ளுங்கள் ( dataEle ) ;
}
}
மேலே உள்ள குறியீட்டின் விளக்கம்:
- முதலில், ' நுகர்வோர் ”,” இணைக்கப்பட்ட பட்டியல் ” மற்றும் தொடர்புடைய பயன்பாடுகள் ஜாவா கோப்பில் இறக்குமதி செய்யப்படுகின்றன. அதன் பிறகு, 'என்ற பெயருடன் முக்கிய வகுப்பு. வேர் ” உருவாக்கப்பட்டது.
- அடுத்து, 'நுகர்வோர்' வகைப் பட்டியலின் இடைமுகத்தை உருவாக்கவும். பெருக்கி ” மற்றும் அதை சமமாக அமைக்கவும் வரிசைப்பட்டியல் ” என்று கீழே உருவாக்கப்படும்.
- இது பயன்படுத்துகிறது ' க்கான 'வளையம்' நீளம் வரை திரும்பும் வரிசைப்பட்டியல் 'பெயர்' dataEle ', மற்றும் ' இன் ஒவ்வொரு தரவு உறுப்புகளையும் பெருக்குகிறது dataEle 'உடன்' 5 ”.
- அதன் பிறகு, ஒரு நொடி ' நுகர்வோர் ” இடைமுகம் உருவாக்கப்படுகிறது, இது ஸ்ட்ரீமில் இருந்து பெருக்கும் செயல்முறைக்குப் பிறகு மீட்டெடுக்கப்படும் கன்சோலில் உள்ள ஒவ்வொரு உறுப்பையும் அச்சிடுகிறது.
- இப்போது, போலி தரவு கூறுகளை உருவாக்கி சேர்க்கவும். dataEle ”வரிசைப்பட்டியல்.
- இறுதியில், ' பின்னர் () 'முறை' என்று அழைக்கப்படுகிறது ஏற்றுக்கொள்() 'ஏற்றுக்கொள்ளும் முறை' dataEle 'வரிசைப்பட்டியல் மற்றும் முடிவை வழங்குகிறது' பெருக்கி ' வரிசையில்.
செயல்படுத்தும் கட்டம் முடிந்த பிறகு:
ஸ்னாப்ஷாட், '' ஐப் பயன்படுத்தி பெருக்கல் பணி முடிந்தது என்பதைக் காட்டுகிறது. பின்னர் () 'முறை' நுகர்வோர் ' இடைமுகம்.
எடுத்துக்காட்டு 2: “ஏற்றுக்கொள்()” முறையின் பயன்பாடு
' ஏற்றுக்கொள்() 'முறை என்பது ஒரு செயல்பாட்டு முறையாகும்' நுகர்வோர் ' இடைமுகம். இது ஒரு வகை வாதத்தை ஏற்றுக்கொள்கிறது ' டி ” மற்றும் அதில் குறிப்பிட்ட/தேவையான செயல்பாடுகளைச் செய்கிறது. மதிப்பு ' ஏதுமில்லை 'ஏற்றுக்கொள்ளாததால் அதை வழங்கக்கூடாது' ஏதுமில்லை ” மதிப்புகள் மற்றும் விதிவிலக்கை உருவாக்குகிறது.
அதன் தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது:
வெற்றிடத்தை ஏற்றுக்கொள்வது ( < வலுவான > டி வலுவான > டி )
மேலே உள்ள தொடரியல், ' டி ” என்பது சில செயல்பாடுகள் இயக்கப்படும் ஒற்றை வாதம்.
ஒரு சிறந்த புரிதலுக்கு கீழே உள்ள குறியீட்டு தொகுதியைப் பார்வையிடலாம்:
java.util.ArrayList இறக்குமதி;java.util.LinkedList இறக்குமதி;
java.util.List இறக்குமதி;
இறக்குமதி java.util.function.Consumer;
// பயன்பாடுகளை இறக்குமதி செய்கிறது உள்ளே ஜாவா கோப்பு
பொது வர்க்க ரூட் {
பொது நிலையான வெற்றிட முக்கிய ( சரம் ஆர்க்ஸ் [ ] ) // முக்கிய முறையை உருவாக்குதல்
{
நுகர்வோர் < முழு > disp = k - > System.out.println ( கே ) ;
disp.accept ( 255 ) ;
நுகர்வோர் < பட்டியல் < முழு > > பெருக்கு = dataEle - >
{
க்கான ( int k = 0 ; கே < dataEle.size ( ) ; k++ )
dataEle.set ( கே, 5 * dataEle.get ( கே ) ) ;
} ;
நுகர்வோர் < பட்டியல் < முழு > >
அச்சுகள் = dataEle - > dataEle.stream ( ) .ஒவ்வொரு ( j - > System.out.print ( j + '
' ) ) ;
பட்டியல் < முழு > dataEle = புதிய ArrayList < முழு > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// ஏற்றுக்கொள்வதைப் பயன்படுத்தி மாற்றியமைக்கவும் ( )
பெருக்கவும்.ஏற்றுக்கொள்ளவும் ( dataEle ) ;
// ஏற்றுக்கொள்வதைப் பயன்படுத்தி dispList ஐ செயல்படுத்தவும் ( )
அச்சிடுகிறது.ஏற்றுக்கொள்ளுங்கள் ( dataEle ) ;
}
}
மேலே உள்ள குறியீட்டின் விளக்கம்:
- முதலில், ' நுகர்வோர் 'இடைமுகம்' என்று பெயரிடப்பட்டது disp ” என்பது உருவாக்கப்பட்டது, இது எந்தச் செயல்பாட்டையும் செய்யாமல், கன்சோலில் வழங்கப்பட்ட அளவுருக்களைக் காண்பிக்கும்.
- இப்போது, ' ஏற்றுக்கொள்() 'முறை' என்று அழைக்கப்படுகிறது disp 'நுகர்வோர் மற்றும் மதிப்பு' 255 ” இந்த முறைக்கு அனுப்பப்பட்டது.
- அடுத்து, மற்றொன்று ' நுகர்வோர் 'இடைமுகம் உருவாக்கப்பட்டது, இது' ஐப் பயன்படுத்துகிறது க்கான ” என்ற பெயரிடப்பட்ட வரிசைப்பட்டியலின் ஒவ்வொரு உறுப்பிலும் பெருக்கத்தைப் பயன்படுத்துவதற்கான வளையம் dataEle ”.
- அதன் பிறகு, மேலும் ஒன்றை உருவாக்கவும் ' நுகர்வோர் 'இடைமுகம்' காட்ட dataEle ஸ்ட்ரீமில் இருந்து வரும் பெருக்கத்தைப் பயன்படுத்திய பிறகு உறுப்புகள் விளைகின்றன.
- அடுத்து, ArrayList ஐ துவக்கவும் ' dataEle போலி தரவு கூறுகளுடன் '' பயன்படுத்தவும் ஏற்றுக்கொள்() 'முறையுடன்' பெருக்கி ' இடைமுகம்.
- இறுதியில், அழைக்கவும் ' ஏற்றுக்கொள்() 'பயன்படுத்தும் முறை' அச்சிடுகிறது ” கன்சோல் பதிவில் பெருக்கலைப் பயன்படுத்திய பிறகு முடிவைக் காட்ட இடைமுகம்.
மரணதண்டனை முடிந்த பிறகு:
மேலே உள்ள ஸ்னாப்ஷாட், பல நுகர்வோர் இடைமுகங்கள் ஒரு நேரத்தில் ஒன்று என அழைக்கப்படுவதைக் காட்டுகிறது ' ஏற்றுக்கொள்() ”முறை.
எடுத்துக்காட்டு 3: செயல்பாட்டிற்குப் பிறகு விதிவிலக்கைக் கையாளுதல்
விதிவிலக்கு எழும்போது ' பிறகு 'செயல்பாடு' பின்னர் () 'முறையானது' கொண்டுள்ளது ஏற்றுக்கொள்() ”முறை. கீழே காட்டப்பட்டுள்ளபடி, நுகர்வோர் இடைமுக முறைகளைப் பயன்படுத்தி இடைமுகங்களால் செயலாக்கப்படும் தரவை இது ஒரு இடைமுகமாக உருவாக்குகிறது:
java.util.ArrayList இறக்குமதி;java.util.LinkedList இறக்குமதி;
java.util.List இறக்குமதி;
இறக்குமதி java.util.function.Consumer;
பொது வர்க்க ரூட் {
பொது நிலையான வெற்றிட முக்கிய ( சரம் ஆர்க்ஸ் [ ] )
{
நுகர்வோர் < பட்டியல் < முழு > > பெருக்கி = dataEle - >
{
க்கான ( int j = 0 ; ஜே < = dataEle.size ( ) ; j++ )
dataEle.set ( j, 5 * dataEle.get ( ஜே ) ) ;
} ;
// முழு எண்களின் பட்டியலைக் காண்பிக்க நுகர்வோர்
நுகர்வோர் < பட்டியல் < முழு > >
அச்சு = dataEle - > dataEle.stream ( ) .ஒவ்வொரு ( நான் - > System.out.print ( நான் + '' ) ) ;
பட்டியல் < முழு > dataEle = புதிய ArrayList < முழு > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
முயற்சி {
அச்சு.மற்றும் பிறகு ( பெருக்கி ) .ஏற்றுக்கொள்ளுங்கள் ( dataEle ) ;
}
பிடி ( விதிவிலக்கு இ ) {
System.out.println ( 'விதிவிலக்கு:' + மற்றும் ) ;
}
}
}
மேலே உள்ள குறியீடு தொகுதியின் விளக்கம்:
- முதலில், ' நுகர்வோர் 'இடைமுகம் உருவாக்கப்பட்டது, இது வெறுமனே பல' 5 ” வழங்கப்பட்ட வரிசைப்பட்டியலில் உள்ள தரவு உறுப்புகளுடன் முழு எண்கள்.
- அடுத்து, இரண்டாவது ' நுகர்வோர் ” ஸ்ட்ரீம் மூலம் பெறப்படும் வரிசைப்பட்டியலின் ஒவ்வொரு தரவு உறுப்பையும் காட்ட இடைமுகம் உருவாக்கப்பட்டது.
- அதன் பிறகு, ArrayList உருவாக்கப்பட்டு போலி முழு எண் வகை மதிப்புகளுடன் துவக்கப்படும்.
- பின்னர், ' முயற்சி 'பிளாக் பயன்படுத்தப்படுகிறது இதில்' பின்னர் () 'முறை' என்று அழைக்கப்படுகிறது அச்சு ' இடைமுகம்.
- இது ' IndexOutOfBoundsException ' ஏனெனில் ' க்கான 'லூப் மறு செய்கை வரம்பு மீறப்பட்டது, இது ' பிடி ” தொகுதி.
செயல்படுத்தும் கட்டம் முடிந்த பிறகு:
IndexOutOfBoundsException ஆனது கம்பைலரால் உருவாக்கப்பட்டது என்பதை ஸ்னாப்ஷாட் காட்டுகிறது.
முடிவுரை
' நுகர்வோர் 'இடைமுகம் மறுபயன்படுத்தக்கூடிய நடத்தையை வரையறுப்பதற்கும், உள்ளீட்டுத் தரவில் முடிவுகளைத் தராமல் செயல்களைச் செய்வதற்கும் ஒரு வழியை வழங்குகிறது. இது ' ஏற்றுக்கொள்() 'மற்றும்' பின்னர் () ”முறைகள். இது பெரும்பாலும் தரவு செயலாக்கப் பணிகளுக்குப் பயன்படுத்தப்படுகிறது, அங்கு பயனர்கள் சேகரிப்பு அல்லது ஸ்ட்ரீமின் ஒவ்வொரு உறுப்புக்கும் ஒரு செயலைச் செய்ய வேண்டும். இது ஜாவாவில் நுகர்வோர் இடைமுகத்தின் பயன்பாடு மற்றும் செயல்படுத்தல் பற்றியது.