சமம் & ஹாஷ்கோட் முறைகள்: அவற்றை ஏன், எங்கு பயன்படுத்த வேண்டும், அவை எவ்வாறு செயல்படுகின்றன

"இப்போது நான் உங்களுக்கு உதவக்கூடிய சில முறைகளைப் பற்றி சொல்கிறேன்:  சமம்(பொருள் o) & ஹாஷ்கோடு() ."

"ஜாவாவில், குறிப்பு மாறிகளை ஒப்பிடும் போது, ​​பொருள்களே ஒப்பிடப்படுவதில்லை, மாறாக பொருள்களின் குறிப்புகள் என்பதை நீங்கள் ஏற்கனவே நினைவில் வைத்திருக்கலாம்."

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i==j);

Integer i = new Integer(1);
Integer j = i;
System.out.println(i==j);

"ஆம், எனக்கு அது நினைவிருக்கிறது."

சமமானவர்கள்  . _

"சமமான முறை என்பது இங்கு நிலையான தீர்வாகும். பொருள்கள் உள்ளே சேமித்து வைக்கப்பட்டுள்ளதை ஒப்பிடுவதன் மூலம் அவை உள்நிலையில் ஒரே மாதிரியானவையா என்பதை தீர்மானிப்பதே சமம் முறையின் நோக்கமாகும்."

"இது அனைத்தும் toString() முறையைப் போலவே உள்ளது."

பொருள் வகுப்பு சமமான முறையின் சொந்த செயலாக்கத்தைக் கொண்டுள்ளது, இது குறிப்புகளை ஒப்பிடுகிறது:

public boolean equals(Object obj)
{
return (this == obj);
}

"அருமை... மீண்டும் அதற்குத் திரும்புவோம், நாங்கள்?"

"உங்கள் கன்னத்தை மேலே வைத்திருங்கள்! இது உண்மையில் மிகவும் தந்திரமானது."

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

"ஒரு உதாரணம் தர முடியுமா?"

"நிச்சயமாக. கணிதப் பின்னங்களைக் குறிக்கும் ஒரு வகுப்பு நம்மிடம் இருப்பதாக வைத்துக்கொள்வோம். அது இப்படி இருக்கும்:"

class Fraction
{
private int numerator;
private int denominator;
Fraction(int numerator, int denominator)
{
this.numerator  = numerator;
this.denominator = denominator;
}public boolean equals(Object obj)
{
if (obj==null)
return false;

if (obj.getClass() != this.getClass() )
return false;

Fraction other = (Fraction) obj;
return this.numerator* other.denominator == this.denominator * other.numerator;
}
}

"இப்போது, ​​இந்த உதாரணத்தைப் பிரிப்போம்."

" சமமான முறையை நாங்கள் மீறுகிறோம் , எனவே பின்னம் பொருள்கள் அவற்றின் சொந்த செயலாக்கத்தைக் கொண்டிருக்கும்.

"முறையில் பல சோதனைகள் உள்ளன:"

" 1)  ஒப்பிடுவதற்கு அனுப்பப்பட்ட பொருள் பூஜ்யமாக இருந்தால் , அந்த பொருள்கள் சமமாக இருக்காது

" 2) ஒரு வகுப்பு ஒப்பீடு. பொருள்கள் வெவ்வேறு வகுப்புகளின் நிகழ்வுகளாக இருந்தால், அவற்றை ஒப்பிட்டுப் பார்க்க மாட்டோம். அதற்குப் பதிலாக, இவை வெவ்வேறு பொருள்கள் என்பதைக் குறிக்க, உடனடியாக ரிட்டர்ன் ஃபால்லைப்  பயன்படுத்துவோம் ."

" 3)  2/3 என்பது 4/6 க்கு சமம் என்பதை இரண்டாம் வகுப்பிலிருந்தே அனைவரும் நினைவில் வைத்திருக்கிறார்கள். ஆனால் அதை எப்படிச் சரிபார்ப்பது?"

"அதன்படி, சமன் முறையின் மூன்றாம் பகுதியில் , நாம் அனுப்பப்பட்ட பொருளை ஒரு பின்னத்திற்கு மாற்றி, பின்னங்களை ஒப்பிடுகிறோம்."

"புரிகிறது. எண்கணிதத்தை எண்கணிதத்துடன் ஒப்பிட்டுப் பார்த்தால், 2/3 என்பது 4/6க்கு சமமாகாது."

"ஒரு வகுப்பின் டெவலப்பருக்கு மட்டுமே அதைச் சரியாக ஒப்பிடத் தெரியும் என்று நீங்கள் கூறியதன் அர்த்தம் இப்போது எனக்குப் புரிகிறது."

"ஆம், ஆனால் அது பாதி கதை மட்டுமே.  மற்றொரு முறை உள்ளது: hashCode() "

"சமமான முறை பற்றி எல்லாம் இப்போது அர்த்தமுள்ளதாக இருக்கிறது, ஆனால் நமக்கு ஏன்  ஹாஷ்கோட் () தேவை? "

" விரைவான ஒப்பீடுகளுக்கு ஹாஷ்கோட் முறை தேவை."

" சமமான முறை ஒரு பெரிய குறைபாட்டைக் கொண்டுள்ளது: இது மிகவும் மெதுவாக வேலை செய்கிறது. உங்களிடம் மில்லியன் கணக்கான தனிமங்கள் உள்ளன மற்றும் அதில் ஒரு குறிப்பிட்ட பொருள் உள்ளதா என்பதைச் சரிபார்க்க வேண்டும். அதை எப்படி செய்வது?"

"நான் ஒரு வளையத்தைப் பயன்படுத்தி அனைத்து உறுப்புகளிலும் சுழற்சி செய்யலாம் மற்றும் தொகுப்பில் உள்ள ஒவ்வொரு பொருளுடனும் பொருளை ஒப்பிடலாம். நான் ஒரு பொருத்தத்தைக் கண்டுபிடிக்கும் வரை."

"அது இல்லை என்றால்? பொருள் இல்லை என்று கண்டுபிடிக்க நாம் ஒரு மில்லியன் ஒப்பீடுகளை நடத்துவோம்? அது நிறைய போல் தெரியவில்லையா?"

"ஆமாம், அதுவும் பல ஒப்பீடுகள் என்று நான் அறிவேன். வேறு வழி இருக்கிறதா?"

"ஆம், இதற்கு நீங்கள் ஹாஷ்கோடு () ஐப் பயன்படுத்தலாம் .

ஹாஷ்கோட் ( ) முறையானது ஒவ்வொரு பொருளுக்கும் ஒரு குறிப்பிட்ட எண்ணை வழங்குகிறது. ஒரு வகுப்பின் டெவலப்பர், சமமான முறைக்கு அவர் அல்லது அவள் செய்வது போலவே, எந்த எண்ணைத் திரும்பப் பெற வேண்டும் என்பதைத் தீர்மானிக்கிறார்.

"ஒரு உதாரணத்தைப் பார்ப்போம்:"

"உங்களிடம் ஒரு மில்லியன் 10-இலக்க எண்கள் இருப்பதாக கற்பனை செய்து பாருங்கள். பிறகு, ஒவ்வொரு எண்ணின் ஹாஷ்கோடு எண்ணை 100 ஆல் வகுத்த பிறகு மீதமுள்ளதாக மாற்றலாம்."

இங்கே ஒரு உதாரணம்:

"ஆமாம், அது அர்த்தமுள்ளதாக இருக்கிறது. இந்த ஹாஷ்கோடை என்ன செய்வது?"

"எண்களை ஒப்பிடுவதற்குப் பதிலாக, அவற்றின் ஹாஷ்கோடுகளை ஒப்பிடுகிறோம் . அது வேகமானது."

"அவர்களின் ஹாஷ்கோடுகள் சமமாக இருந்தால் மட்டுமே நாங்கள் சமமானவர்கள் என்று அழைக்கிறோம் ."

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

"இல்லை, நீங்கள் மிகக் குறைந்த எண்ணிக்கையிலான ஒப்பீடுகளுடன் தப்பித்துக்கொள்ளலாம்."

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

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

"இந்த எடுத்துக்காட்டில், தங்குமிடம் எண் (17) என்பது ஹாஷ்கோட் ஆகும்."

"ஹாஷ்கோட் செயல்பாட்டை செயல்படுத்தும் டெவலப்பர் பின்வருவனவற்றை அறிந்திருக்க வேண்டும்:"

A)  இரண்டு வெவ்வேறு பொருள்கள் ஒரே ஹாஷ்கோடைக் கொண்டிருக்கலாம்  (வெவ்வேறு நபர்கள் ஒரே தங்குமிடத்தில் வாழலாம்)

B)  ஒரே மாதிரியான பொருள்கள்  ( சமமான முறையின்படி )  ஒரே ஹாஷ்கோடு இருக்க வேண்டும். .

சி)  ஹாஷ் குறியீடுகள் தேர்ந்தெடுக்கப்பட வேண்டும், அதனால் ஒரே ஹாஷ்கோடு கொண்ட பல்வேறு பொருள்கள் இல்லை.  இருந்தால், ஹாஷ்கோடுகளின் சாத்தியமான நன்மைகள் இழக்கப்படும் (நீங்கள் தங்குமிடம் 17 க்குச் சென்று, பாதிப் பல்கலைக்கழகம் அங்கு வாழ்கிறது என்பதைக் கண்டறியவும். பம்மர்!).

"இப்போது மிக முக்கியமான விஷயம். நீங்கள் சமமான முறையை மீறினால், நீங்கள் முற்றிலும் ஹாஷ்கோட் () முறையை மேலெழுத வேண்டும் மற்றும் மேலே விவரிக்கப்பட்ட மூன்று விதிகளுக்கு இணங்க வேண்டும்.

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

"எங்கள் பின்னம் எடுத்துக்காட்டில், ஹாஷ்கோடுகளை எண்ணுக்குச் சமமாக மாற்றினால், 2/3 மற்றும் 4/6 பின்னங்கள் வெவ்வேறு ஹாஷ்கோடுகளைக் கொண்டிருக்கும். பின்னங்கள் ஒரே மாதிரியானவை மற்றும் சமமான முறை அவை ஒன்றுதான் என்று கூறுகிறது, ஆனால் அவற்றின் ஹாஷ்கோடுகள் கூறுகின்றன சமமானவற்றைப் பயன்படுத்துவதற்கு முன், ஹாஷ்கோடைப் பயன்படுத்துவதை ஒப்பிட்டுப் பார்த்தால், பொருள்கள் வேறுபட்டவை என்று நாம் முடிவு செய்கிறோம், மேலும் நாம் அதைச் சமமான முறைக்குக் கூட உருவாக்கவில்லை."

இங்கே ஒரு உதாரணம்:

"எனவே பின்னங்களுக்கு ஹாஷ்கோடைச் செயல்படுத்த சரியான வழி என்ன?"

"சமமான பின்னங்கள் ஒரே ஹாஷ்கோடைக் கொண்டிருக்க வேண்டும் என்பதை இங்கே நீங்கள் நினைவில் கொள்ள வேண்டும்."

" பதிப்பு 1 : ஹாஷ்கோட் முழு எண் பிரிவின் விளைவாக சமம்."

"7/5 மற்றும் 6/5க்கு, இது 1 ஆக இருக்கும்."

"4/5 மற்றும் 3/5க்கு, இது 0 ஆக இருக்கும்."

"ஆனால் இந்த விருப்பம் வேண்டுமென்றே 1 க்கும் குறைவான பின்னங்களை ஒப்பிடுவதற்கு மிகவும் பொருத்தமானது அல்ல. ஹாஷ்கோட் (முழு எண் பிரிவின் முடிவு) எப்போதும் 0 ஆக இருக்கும்."

" பதிப்பு 2 : ஹாஷ்கோட், எண் மூலம் வகுப்பின் முழு எண் பிரிவின் விளைவாக சமம்."

"இந்த விருப்பம் 1 க்கும் குறைவாக இருக்கும் நிகழ்வுகளுக்கு ஏற்றது. பின்னம் 1 க்கும் குறைவாக இருந்தால், அதன் தலைகீழ் 1 ஐ விட அதிகமாக இருக்கும். மேலும் அனைத்து பின்னங்களையும் நாம் தலைகீழாக மாற்றினால், ஒப்பீடுகள் எந்த விதத்திலும் பாதிக்கப்படாது."

"எங்கள் இறுதி பதிப்பு இரண்டு தீர்வுகளையும் ஒருங்கிணைக்கிறது:"

public int hashCode()
{
return numerator/denominator + denominator/numerator;
}

2/3 மற்றும் 4/6 ஐப் பயன்படுத்தி சோதிப்போம். அவை ஒரே மாதிரியான ஹாஷ்கோடுகளைக் கொண்டிருக்க வேண்டும்:

"இப்பொழுது இத்துடன் நிறைவடைகிறது."

"நன்றி, எல்லி. அது மிகவும் சுவாரஸ்யமானது."