సమాన & హ్యాష్‌కోడ్ పద్ధతులు: వాటిని ఎందుకు మరియు ఎక్కడ ఉపయోగించాలి మరియు అవి ఎలా పని చేస్తాయి

"ఇప్పుడు నేను మీకు సహాయపడే కొన్ని పద్ధతుల గురించి చెబుతాను:  సమానం(ఆబ్జెక్ట్ 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() "

"ఈక్వెల్స్ మెథడ్ గురించి ప్రతిదీ ఇప్పుడు అర్థవంతంగా ఉంది, కానీ మనకు  హ్యాష్‌కోడ్ () ఎందుకు అవసరం? "

" త్వరిత పోలికలకు హ్యాష్‌కోడ్ పద్ధతి అవసరం."

" ఈక్వల్స్ పద్ధతిలో ప్రధాన ప్రతికూలత ఉంది: ఇది చాలా నెమ్మదిగా పని చేస్తుంది. మీరు మిలియన్ల కొద్దీ మూలకాల సమితిని కలిగి ఉన్నారని అనుకుందాం మరియు అది నిర్దిష్ట వస్తువును కలిగి ఉందో లేదో తనిఖీ చేయాలి. మీరు దీన్ని ఎలా చేస్తారు?"

"నేను ఒక లూప్‌ని ఉపయోగించి అన్ని మూలకాల ద్వారా చక్రం తిప్పగలను మరియు సెట్‌లోని ప్రతి వస్తువుతో వస్తువును సరిపోల్చగలను. నేను సరిపోలికను కనుగొనే వరకు."

"మరి అది అక్కడ లేకుంటే? ఆ వస్తువు లేదని కనుక్కోవడానికి ఒక మిలియన్ పోలికలు చేస్తాం? అది చాలా ఎక్కువ అనిపించడం లేదా?"

"అవును, అది చాలా పోలికలు అని నేను కూడా గుర్తించాను. వేరే మార్గం ఉందా?"

"అవును, మీరు దీని కోసం హ్యాష్‌కోడ్ () ని ఉపయోగించవచ్చు .

HashCode ( ) పద్ధతి ప్రతి వస్తువుకు నిర్దిష్ట సంఖ్యను అందిస్తుంది. ఒక తరగతి డెవలపర్ ఈక్వల్స్ మెథడ్ కోసం అతను లేదా ఆమె చేసినట్లే, ఏ సంఖ్యను తిరిగి ఇవ్వాలో నిర్ణయిస్తారు.

"ఒక ఉదాహరణ చూద్దాం:"

"మీ వద్ద మిలియన్ 10-అంకెల సంఖ్యలు ఉన్నాయని ఊహించుకోండి. ఆపై, మీరు ప్రతి సంఖ్య యొక్క హ్యాష్‌కోడ్‌ను 100తో భాగించిన తర్వాత మిగిలినదిగా మార్చవచ్చు."

ఇక్కడ ఒక ఉదాహరణ:

"అవును, అది అర్ధమే. మరి ఈ హ్యాష్‌కోడ్‌తో మనం ఏమి చేయాలి?"

"సంఖ్యలను పోల్చడానికి బదులుగా, మేము వారి హ్యాష్‌కోడ్‌లను సరిపోల్చాము . ఇది వేగంగా ఉంటుంది."

"మరియు మేము వారి హాష్‌కోడ్‌లు సమానంగా ఉంటేనే సమానం అని పిలుస్తాము ."

"అవును, అది వేగవంతమైనది. కానీ మనం ఇంకా మిలియన్ పోలికలు చేయాలి. మేము కేవలం చిన్న సంఖ్యలను సరిపోల్చుతున్నాము మరియు సరిపోలే హ్యాష్‌కోడ్‌లతో ఏవైనా నంబర్‌లకు సమానమైన వాటిని కాల్ చేయాల్సి ఉంటుంది."

"లేదు, మీరు చాలా తక్కువ సంఖ్యలో పోలికలతో బయటపడవచ్చు."

"మా సెట్ స్టోర్ నంబర్‌లను హ్యాష్‌కోడ్ ద్వారా క్రమబద్ధీకరించిందని ఊహించండి (వాటిని ఈ విధంగా క్రమబద్ధీకరించడం తప్పనిసరిగా వాటిని సమూహపరచడం, ఎందుకంటే ఒకే హ్యాష్‌కోడ్‌తో కూడిన సంఖ్యలు ఒకదానికొకటి పక్కన ఉంటాయి). అప్పుడు మీరు అసంబద్ధ సమూహాలను చాలా త్వరగా మరియు సులభంగా విస్మరించవచ్చు. ఇది సరిపోతుంది. దాని హ్యాష్‌కోడ్ ఆబ్జెక్ట్ యొక్క హ్యాష్‌కోడ్‌తో సరిపోలుతుందో లేదో చూడటానికి ఒక్కో సమూహానికి ఒకసారి తనిఖీ చేయండి."

"మీరు కనుచూపుతో గుర్తించగలిగే స్నేహితుడి కోసం వెతుకుతున్న విద్యార్థిగా ఊహించుకోండి మరియు డార్మ్ 17లో నివసిస్తున్నారని మాకు తెలుసు. మీరు యూనివర్సిటీలోని ప్రతి వసతి గృహానికి వెళ్లి, 'ఇది వసతి గృహం 17నా?' అది కాకపోతే, మీరు వసతి గృహంలో ఉన్న ప్రతి ఒక్కరినీ విస్మరించి, తదుపరి దానికి వెళ్లండి. సమాధానం 'అవును' అయితే, మీరు మీ స్నేహితుడి కోసం వెతుకుతూ ప్రతి గదిని దాటడం ప్రారంభించండి."

"ఈ ఉదాహరణలో, డార్మ్ నంబర్ (17) అనేది హ్యాష్‌కోడ్."

"హాష్‌కోడ్ ఫంక్షన్‌ని అమలు చేసే డెవలపర్ తప్పనిసరిగా కింది వాటిని తెలుసుకోవాలి:"

ఎ)  రెండు వేర్వేరు వస్తువులు ఒకే హ్యాష్‌కోడ్‌ను కలిగి ఉంటాయి  (వేర్వేరు వ్యక్తులు ఒకే వసతి గృహంలో నివసించవచ్చు)

బి)  ఒకేలా ఉండే వస్తువులు  ( ఈక్వల్స్ పద్ధతి ప్రకారం )  తప్పనిసరిగా ఒకే హ్యాష్‌కోడ్‌ని కలిగి ఉండాలి. .

సి)  హాష్ కోడ్‌లను తప్పనిసరిగా ఎంచుకోవాలి, తద్వారా ఒకే హ్యాష్‌కోడ్‌తో విభిన్న వస్తువులు ఉండవు.  ఉన్నట్లయితే, హ్యాష్‌కోడ్‌ల సంభావ్య ప్రయోజనాలు పోతాయి (మీరు డార్మ్ 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 ఉపయోగించి పరీక్షిద్దాం. అవి ఒకేలాంటి హాష్‌కోడ్‌లను కలిగి ఉండాలి:

"ఇప్పటికి ఇంతే."

"ధన్యవాదాలు, ఎల్లీ. అది నిజంగా ఆసక్తికరంగా ఉంది."