సమానం మరియు హాష్‌కోడ్ పద్ధతులు: ఉత్తమ పద్ధతులు

హాయ్! ఈ రోజు మనం జావాలో రెండు ముఖ్యమైన పద్ధతుల గురించి మాట్లాడుతాము: equals()మరియు hashCode(). మేము వారిని కలవడం ఇదే మొదటిసారి కాదు: కోడ్‌జిమ్ కోర్సు గురించి ఒక చిన్న పాఠంతోequals() ప్రారంభమవుతుంది — మీరు దానిని మరచిపోయినా లేదా ఇంతకు ముందు చూడకపోయినా చదవండి... నేటి పాఠంలో, మేము దీని గురించి మాట్లాడుతాము ఈ భావనలు వివరంగా. మరియు నన్ను నమ్మండి, మనం మాట్లాడటానికి ఏదైనా ఉంది! అయితే మనం కొత్తదానికి వెళ్లే ముందు, మనం ఇప్పటికే కవర్ చేసిన వాటిని రిఫ్రెష్ చేద్దాం :) మీకు గుర్తున్నట్లుగా, సాధారణంగా రెండు వస్తువులను ఆపరేటర్‌ని ఉపయోగించి పోల్చడం చెడ్డ ఆలోచన, ==ఎందుకంటే ==రిఫరెన్స్‌లను సరిపోల్చడం. ఇటీవలి పాఠం నుండి కార్లతో మా ఉదాహరణ ఇక్కడ ఉంది:

public class Car {

   String model;
   int maxSpeed;

   public static void main(String[] args) {

       Car car1 = new Car();
       car1.model = "Ferrari";
       car1.maxSpeed = 300;

       Car car2 = new Car();
       car2.model = "Ferrari";
       car2.maxSpeed = 300;

       System.out.println(car1 == car2);
   }
}

కన్సోల్ అవుట్‌పుట్:

false

మేము రెండు సారూప్య వస్తువులను సృష్టించినట్లు కనిపిస్తోంది Car: రెండు కార్ ఆబ్జెక్ట్‌ల సంబంధిత ఫీల్డ్‌ల విలువలు ఒకేలా ఉన్నాయి, కానీ పోలిక ఫలితం ఇప్పటికీ తప్పు. మనకు ఇప్పటికే కారణం తెలుసు: ది car1మరియు car2రిఫరెన్స్‌లు వేర్వేరు మెమరీ చిరునామాలను సూచిస్తాయి, కాబట్టి అవి సమానంగా ఉండవు. కానీ మేము ఇప్పటికీ రెండు వస్తువులను పోల్చాలనుకుంటున్నాము, రెండు సూచనలు కాదు. వస్తువులను పోల్చడానికి ఉత్తమ పరిష్కారం పద్ధతి equals().

సమానం () పద్ధతి

మేము ఈ పద్ధతిని మొదటి నుండి సృష్టించడం లేదని మీరు గుర్తుంచుకోవచ్చు, బదులుగా మేము దానిని భర్తీ చేస్తాము: పద్ధతి equals()తరగతిలో నిర్వచించబడింది Object. దాని సాధారణ రూపంలో, ఇది పెద్దగా ఉపయోగపడదు:

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

ఈ పద్ధతిని తరగతిలో ఈ విధంగా equals()నిర్వచించారు Object. ఇది మరోసారి సూచనల పోలిక. ఎందుకు అలా చేశారు? సరే, మీ ప్రోగ్రామ్‌లోని ఏ వస్తువులు సమానంగా పరిగణించబడుతున్నాయో మరియు ఏవి కావు అని భాష సృష్టికర్తలకు ఎలా తెలుసు? :) ఇది పద్ధతి యొక్క ప్రధాన అంశం equals()— తరగతి యొక్క సృష్టికర్త తరగతి వస్తువుల సమానత్వాన్ని తనిఖీ చేసేటప్పుడు ఏ లక్షణాలను ఉపయోగించాలో నిర్ణయిస్తాడు. అప్పుడు మీరు equals()మీ తరగతిలోని పద్ధతిని భర్తీ చేస్తారు. "ఏ లక్షణాలను నిర్ణయిస్తుంది" అనే అర్థం మీకు సరిగ్గా అర్థం కాకపోతే, ఒక ఉదాహరణను పరిశీలిద్దాం. మనిషిని సూచించే సాధారణ తరగతి ఇక్కడ ఉంది: Man.

public class Man {

   private String noseSize;
   private String eyesColor;
   private String haircut;
   private boolean scars;
   private int dnaCode;

public Man(String noseSize, String eyesColor, String haircut, boolean scars, int dnaCode) {
   this.noseSize = noseSize;
   this.eyesColor = eyesColor;
   this.haircut = haircut;
   this.scars = scars;
   this.dnaCode = dnaCode;
}

   // Getters, setters, etc.
}

ఇద్దరు వ్యక్తులు ఒకేలాంటి కవలలు కాదా లేదా కేవలం ఒకేలా ఉన్నారా అని నిర్ధారించడానికి మేము ప్రోగ్రామ్‌ను వ్రాస్తున్నామని అనుకుందాం. మాకు ఐదు లక్షణాలు ఉన్నాయి: ముక్కు పరిమాణం, కంటి రంగు, జుట్టు శైలి, మచ్చల ఉనికి మరియు DNA పరీక్ష ఫలితాలు (సరళత కోసం, మేము దీనిని పూర్ణాంక కోడ్‌గా సూచిస్తాము). ఈ లక్షణాలలో ఏది ఒకేలాంటి కవలలను గుర్తించడానికి మా ప్రోగ్రామ్‌ను అనుమతిస్తుంది అని మీరు అనుకుంటున్నారు? వాస్తవానికి, DNA పరీక్ష మాత్రమే హామీని అందిస్తుంది. ఇద్దరు వ్యక్తులు ఒకే కంటి రంగు, హ్యారీకట్, ముక్కు మరియు మచ్చలు కూడా కలిగి ఉండవచ్చు - ప్రపంచంలో చాలా మంది వ్యక్తులు ఉన్నారు మరియు అక్కడ డోపెల్‌గాంజర్‌లు లేరని హామీ ఇవ్వడం అసాధ్యం. కానీ మనకు నమ్మదగిన యంత్రాంగం అవసరం: DNA పరీక్ష ఫలితం మాత్రమే ఖచ్చితమైన ముగింపును అనుమతిస్తుంది. మా పద్ధతికి దీని అర్థం ఏమిటి equals()? మేము దానిని భర్తీ చేయాలిManతరగతి, మా ప్రోగ్రామ్ యొక్క అవసరాలను పరిగణనలోకి తీసుకుంటుంది. int dnaCodeపద్ధతి రెండు వస్తువుల క్షేత్రాన్ని సరిపోల్చాలి . అవి సమానంగా ఉంటే, అప్పుడు వస్తువులు సమానంగా ఉంటాయి.

@Override
public boolean equals(Object o) {
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

ఇది నిజంగా అంత సులభమా? నిజంగా కాదు. మేము ఏదో విస్మరించాము. మా ఆబ్జెక్ట్‌ల కోసం, ఆబ్జెక్ట్ సమానత్వాన్ని స్థాపించడానికి సంబంధించిన ఒక ఫీల్డ్‌ను మాత్రమే మేము గుర్తించాము: dnaCode. ఇప్పుడు మనకు 1 కాదు, 50 సంబంధిత ఫీల్డ్‌లు ఉన్నాయని ఊహించుకోండి. మరియు రెండు వస్తువుల యొక్క మొత్తం 50 ఫీల్డ్‌లు సమానంగా ఉంటే, ఆ వస్తువులు సమానంగా ఉంటాయి. అలాంటి దృశ్యం కూడా సాధ్యమే. ప్రధాన సమస్య ఏమిటంటే, 50 ఫీల్డ్‌లను పోల్చడం ద్వారా సమానత్వాన్ని స్థాపించడం అనేది చాలా సమయం తీసుకునే మరియు వనరులతో కూడిన ప్రక్రియ. ఇప్పుడు మన క్లాస్‌తో పాటుగా Man, Womanలో ఉన్న అదే ఫీల్డ్‌లతో కూడిన క్లాస్ కూడా ఉందని ఊహించుకోండి Man. మరొక ప్రోగ్రామర్ మా తరగతులను ఉపయోగిస్తుంటే, అతను లేదా ఆమె ఇలా కోడ్‌ని సులభంగా వ్రాయవచ్చు:

public static void main(String[] args) {
  
   Man man = new Man(........); // A bunch of parameters in the constructor

   Woman woman = new Woman(.........); // The same bunch of parameters.

   System.out.println(man.equals(woman));
}

ఈ సందర్భంలో, ఫీల్డ్ విలువలను తనిఖీ చేయడం అర్థరహితం: మనకు రెండు వేర్వేరు తరగతుల వస్తువులు ఉన్నాయని మనం తక్షణమే చూడగలం, కాబట్టి అవి సమానంగా ఉండే అవకాశం లేదు! equals()దీనర్థం మనం పోల్చిన వస్తువుల తరగతులను పోల్చి, పద్ధతికి చెక్ జోడించాలి . మనం ఆలోచించడం మంచిది!

@Override
public boolean equals(Object o) {
   if (getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

కానీ మనం ఇంకేదైనా మర్చిపోయామా? హ్మ్... కనిష్టంగా, మనం ఒక వస్తువును దానితో పోల్చడం లేదని తనిఖీ చేయాలి! A మరియు B రిఫరెన్స్‌లు ఒకే మెమరీ చిరునామాను సూచిస్తే, అవి ఒకే వస్తువు, మరియు మనం సమయాన్ని వృథా చేసి 50 ఫీల్డ్‌లను సరిపోల్చాల్సిన అవసరం లేదు.

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

దీని కోసం చెక్‌ను జోడించడం కూడా బాధించదు null: ఏ వస్తువు దీనికి సమానంగా ఉండదు null. కాబట్టి, పద్ధతి పరామితి శూన్యమైతే, అదనపు తనిఖీలలో పాయింట్ లేదు. వీటన్నింటిని దృష్టిలో ఉంచుకుని, తరగతి equals()కోసం మా పద్ధతి Manఇలా కనిపిస్తుంది:

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   Man man = (Man) o;
   return dnaCode == man.dnaCode;
}

మేము పైన పేర్కొన్న అన్ని ప్రారంభ తనిఖీలను చేస్తాము. రోజు చివరిలో, అయితే:

• మేము ఒకే తరగతికి చెందిన రెండు వస్తువులను పోల్చాము
• మరియు పోల్చబడిన వస్తువులు ఒకే వస్తువు కాదు
• మరియు ఆమోదించబడిన వస్తువు కాదుnull

...అప్పుడు మేము సంబంధిత లక్షణాల పోలికకు వెళ్తాము. మాకు, దీని అర్థం dnaCodeరెండు వస్తువుల క్షేత్రాలు. పద్ధతిని భర్తీ చేస్తున్నప్పుడు equals(), ఈ అవసరాలను ఖచ్చితంగా గమనించండి:

1. రిఫ్లెక్సివిటీ.

   equals()ఏదైనా వస్తువును దానితో పోల్చడానికి పద్ధతిని ఉపయోగించినప్పుడు, అది తప్పక నిజమని తిరిగి ఇవ్వాలి .
   మేము ఇప్పటికే ఈ అవసరాన్ని పాటించాము. మా పద్ధతి వీటిని కలిగి ఉంటుంది:

   
   if (this == o) return true;
   

2. సమరూపత.

   ఒకవేళ a.equals(b) == true, b.equals(a)తిరిగి రావాలి true.
   మా పద్ధతి ఈ అవసరాన్ని కూడా తీరుస్తుంది.

3. ట్రాన్సిటివిటీ.

   రెండు వస్తువులు ఏదో ఒక మూడవ వస్తువుతో సమానంగా ఉంటే, అవి ఒకదానికొకటి సమానంగా ఉండాలి.
   ఒకవేళ a.equals(b) == trueమరియు a.equals(c) == true, అప్పుడు b.equals(c)కూడా తప్పక నిజాన్ని అందించాలి.

4. పట్టుదల.

   equals()ప్రమేయం ఉన్న ఫీల్డ్‌లను మార్చినప్పుడు మాత్రమే ఫలితం మారాలి. రెండు వస్తువుల డేటా మారకపోతే, ఫలితం equals()ఎల్లప్పుడూ ఒకే విధంగా ఉండాలి.

5. తో అసమానత null.

   ఏదైనా వస్తువు కోసం, a.equals(null)తప్పక తప్పక అందించాలి
   ఇది కొన్ని "ఉపయోగకరమైన సిఫార్సుల" సమితి మాత్రమే కాదు, ఒరాకిల్ డాక్యుమెంటేషన్‌లో నిర్దేశించిన కఠినమైన ఒప్పందం

hashCode() పద్ధతి

ఇప్పుడు పద్ధతి గురించి మాట్లాడుకుందాం hashCode(). అది ఎందుకు అవసరం? సరిగ్గా అదే ప్రయోజనం కోసం - వస్తువులను పోల్చడానికి. కానీ మనకు ఇప్పటికే ఉంది equals()! మరొక పద్ధతి ఎందుకు? సమాధానం సులభం: పనితీరును మెరుగుపరచడానికి. పద్ధతిని ఉపయోగించి జావాలో సూచించబడిన హాష్ ఫంక్షన్ hashCode()ఏదైనా వస్తువు కోసం స్థిర-పొడవు సంఖ్యా విలువను అందిస్తుంది. జావాలో, పద్ధతి ఏదైనా వస్తువు కోసం hashCode()32-బిట్ సంఖ్య ( )ని అందిస్తుంది . intపద్ధతిని ఉపయోగించి రెండు వస్తువులను పోల్చడం కంటే రెండు సంఖ్యలను పోల్చడం చాలా వేగంగా ఉంటుంది equals(), ప్రత్యేకించి ఆ పద్ధతి అనేక ఫీల్డ్‌లను పరిగణనలోకి తీసుకుంటే. మా ప్రోగ్రామ్ ఆబ్జెక్ట్‌లను పోల్చినట్లయితే, హ్యాష్ కోడ్‌ని ఉపయోగించి దీన్ని చేయడం చాలా సులభం. పద్ధతి ఆధారంగా వస్తువులు సమానంగా ఉంటే మాత్రమే hashCode()పోలిక కొనసాగుతుందిequals()పద్ధతి. మార్గం ద్వారా, హాష్ ఆధారిత డేటా నిర్మాణాలు ఈ విధంగా పనిచేస్తాయి, ఉదాహరణకు, సుపరిచితం HashMap! పద్ధతి hashCode(), equals()పద్ధతి వలె, డెవలపర్ ద్వారా భర్తీ చేయబడుతుంది. అలాగే equals(), ఈ hashCode()పద్ధతికి ఒరాకిల్ డాక్యుమెంటేషన్‌లో అధికారిక అవసరాలు ఉన్నాయి:

1. రెండు ఆబ్జెక్ట్‌లు సమానంగా ఉంటే (అంటే equals()పద్ధతి నిజమని చూపుతుంది), అప్పుడు వాటికి ఒకే హాష్ కోడ్ ఉండాలి.

   లేకుంటే మన పద్ధతులు అర్ధం కావు. మేము పైన చెప్పినట్లుగా, hashCode()పనితీరును మెరుగుపరచడానికి ముందుగా చెక్ చేయాలి. హాష్ కోడ్‌లు భిన్నంగా ఉంటే, మేము పద్ధతిని ఎలా నిర్వచించామో దాని ప్రకారం వస్తువులు వాస్తవానికి సమానంగా ఉన్నప్పటికీ, చెక్ తప్పుగా తిరిగి వస్తుంది equals().

2. hashCode()ఒకే వస్తువుపై పద్ధతిని అనేకసార్లు పిలిచినట్లయితే, అది ప్రతిసారీ అదే సంఖ్యను అందించాలి .

3. నియమం 1 వ్యతిరేక దిశలో పనిచేయదు. రెండు వేర్వేరు వస్తువులు ఒకే హాష్ కోడ్‌ను కలిగి ఉంటాయి.

మూడవ నియమం కొంచెం గందరగోళంగా ఉంది. ఇది ఎలా ఉంటుంది? వివరణ చాలా సులభం. పద్ధతి hashCode()ఒక int. An intఅనేది 32-బిట్ సంఖ్య. ఇది పరిమిత శ్రేణి విలువలను కలిగి ఉంది: -2,147,483,648 నుండి +2,147,483,647 వరకు. మరో మాటలో చెప్పాలంటే, ఒక కోసం కేవలం 4 బిలియన్ల కంటే ఎక్కువ సాధ్యం విలువలు ఉన్నాయి int. ఇప్పుడు మీరు భూమిపై నివసించే ప్రజలందరికి సంబంధించిన డేటాను నిల్వ చేయడానికి ప్రోగ్రామ్‌ను సృష్టిస్తున్నారని ఊహించండి. ప్రతి వ్యక్తి దాని స్వంత వస్తువుకు అనుగుణంగా ఉంటుంది Person(తరగతి మాదిరిగానే Man). గ్రహం మీద ~7.5 బిలియన్ల మంది నివసిస్తున్నారు. మరో మాటలో చెప్పాలంటే, మార్చడం కోసం మనం వ్రాసే అల్గోరిథం ఎంత తెలివైనదైనా సరేPersonపూర్ణాంకానికి సంబంధించిన వస్తువులు, మనకు తగినంత సాధ్యం సంఖ్యలు లేవు. మాకు 4.5 బిలియన్ల సాధ్యమైన పూర్ణాంక విలువలు మాత్రమే ఉన్నాయి, కానీ దాని కంటే చాలా ఎక్కువ మంది వ్యక్తులు ఉన్నారు. అంటే మనం ఎంత ప్రయత్నించినా, కొంతమంది వేర్వేరు వ్యక్తులకు ఒకే రకమైన హాష్ కోడ్‌లు ఉంటాయి. ఇది జరిగినప్పుడు (హాష్ కోడ్‌లు రెండు వేర్వేరు వస్తువులతో సమానంగా ఉంటాయి) మేము దానిని ఘర్షణ అని పిలుస్తాము. పద్ధతిని భర్తీ చేసినప్పుడు hashCode(), ప్రోగ్రామర్ యొక్క లక్ష్యాలలో ఒకటి ఘర్షణల సంభావ్య సంఖ్యను తగ్గించడం. ఈ నిబంధనలన్నింటికీ లెక్కింపు, hashCode()తరగతిలో పద్ధతి ఎలా ఉంటుంది Person? ఇలా:

@Override
public int hashCode() {
   return dnaCode;
}

ఆశ్చర్యంగా ఉందా? :) మీరు అవసరాలను చూస్తే, మేము వాటన్నింటికీ కట్టుబడి ఉన్నట్లు మీరు చూస్తారు. మా పద్దతి నిజమని అందించే వస్తువులు equals()కూడా ప్రకారం సమానంగా ఉంటాయి hashCode(). మన రెండు Personవస్తువులు సమానంగా ఉంటే equals(అంటే, అవి ఒకేలా ఉంటాయి dnaCode), అప్పుడు మా పద్ధతి అదే సంఖ్యను అందిస్తుంది. మరింత క్లిష్టమైన ఉదాహరణను పరిశీలిద్దాం. మా ప్రోగ్రామ్ కార్ కలెక్టర్ల కోసం లగ్జరీ కార్లను ఎంచుకోవాలని అనుకుందాం. సేకరించడం అనేది అనేక ప్రత్యేకతలతో కూడిన సంక్లిష్టమైన అభిరుచి. నిర్దిష్ట 1963 కారు ధర 1964 కారు కంటే 100 రెట్లు ఎక్కువ. 1970 ఎరుపు రంగు కారు అదే సంవత్సరం అదే బ్రాండ్ యొక్క నీలిరంగు కారు కంటే 100 రెట్లు ఎక్కువ ధర ఉంటుంది. మా మునుపటి ఉదాహరణలో, Personక్లాస్‌తో, మేము చాలా ఫీల్డ్‌లను (అంటే మానవ లక్షణాలు) ముఖ్యమైనవిగా విస్మరించి, వాటిని మాత్రమే ఉపయోగించాముdnaCodeపోలికలలో ఫీల్డ్. మేము ఇప్పుడు చాలా విచిత్రమైన రాజ్యంలో పని చేస్తున్నాము, ఇందులో ముఖ్యమైన వివరాలు లేవు! ఇక్కడ మా LuxuryAutoతరగతి ఉంది:

public class LuxuryAuto {

   private String model;
   private int manufactureYear;
   private int dollarPrice;

   public LuxuryAuto(String model, int manufactureYear, int dollarPrice) {
       this.model = model;
       this.manufactureYear = manufactureYear;
       this.dollarPrice = dollarPrice;
   }

   // ...getters, setters, etc.
}

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

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;

   LuxuryAuto that = (LuxuryAuto) o;

   if (manufactureYear != that.manufactureYear) return false;
   if (dollarPrice != that.dollarPrice) return false;
   return model.equals(that.model);
}

మా equals()పద్ధతిలో, మేము ఇంతకు ముందు మాట్లాడిన అన్ని తనిఖీలను మరచిపోలేదు. కానీ ఇప్పుడు మనం మన వస్తువుల యొక్క మూడు రంగాలలో ప్రతిదానిని పోల్చాము. ఈ ప్రోగ్రామ్ కోసం, మనకు సంపూర్ణ సమానత్వం అవసరం, అంటే ప్రతి ఫీల్డ్ యొక్క సమానత్వం. గురించి ఏమిటి hashCode?

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = result + manufactureYear;
   result = result + dollarPrice;
   return result;
}

modelమా తరగతిలోని ఫీల్డ్ ఒక స్ట్రింగ్ . ఇది సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే Stringతరగతి ఇప్పటికే hashCode()పద్ధతిని భర్తీ చేస్తుంది. మేము modelఫీల్డ్ యొక్క హాష్ కోడ్‌ను గణిస్తాము మరియు దానికి ఇతర రెండు సంఖ్యా ఫీల్డ్‌ల మొత్తాన్ని జోడిస్తాము. జావా డెవలపర్‌లు ఘర్షణల సంఖ్యను తగ్గించడానికి ఉపయోగించే ఒక సాధారణ ట్రిక్‌ని కలిగి ఉన్నారు: హాష్ కోడ్‌ను కంప్యూట్ చేస్తున్నప్పుడు, ఇంటర్మీడియట్ ఫలితాన్ని బేసి ప్రైమ్‌తో గుణించండి. అత్యంత సాధారణంగా ఉపయోగించే సంఖ్య 29 లేదా 31. మేము ప్రస్తుతం గణిత సూక్ష్మతలను పరిశోధించము, అయితే భవిష్యత్తులో ఇంటర్మీడియట్ ఫలితాలను తగినంత పెద్ద బేసి సంఖ్యతో గుణించడం హాష్ ఫంక్షన్ యొక్క ఫలితాలను "విస్తరించడానికి" సహాయపడుతుందని గుర్తుంచుకోండి మరియు, తత్ఫలితంగా, అదే హాష్ కోడ్‌తో వస్తువుల సంఖ్యను తగ్గించండి. LuxuryAutoలో మా hashCode()పద్ధతి కోసం, ఇది ఇలా ఉంటుంది:

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = 31 * result + manufactureYear;
   result = 31 * result + dollarPrice;
   return result;
}

మీరు స్టాక్‌ఓవర్‌ఫ్లో ఈ పోస్ట్‌లో , అలాగే జాషువా బ్లాచ్ రాసిన ఎఫెక్టివ్ జావా పుస్తకంలో ఈ మెకానిజం యొక్క అన్ని చిక్కుల గురించి మరింత చదవవచ్చు . చివరగా, ప్రస్తావించదగిన మరో ముఖ్యమైన విషయం. equals()మేము మరియు పద్ధతిని ఓవర్‌రోడ్ చేసిన ప్రతిసారీ hashCode(), ఈ పద్ధతుల్లో పరిగణనలోకి తీసుకోబడే నిర్దిష్ట ఫీల్డ్‌లను మేము ఎంచుకుంటాము. ఈ పద్ధతులు ఒకే రంగాలను పరిగణలోకి తీసుకుంటాయి. equals()కానీ మేము మరియు లో వివిధ రంగాలను పరిగణించవచ్చా hashCode()? సాంకేతికంగా, మేము చేయవచ్చు. కానీ ఇది చెడ్డ ఆలోచన, మరియు ఇక్కడ ఎందుకు ఉంది:

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;

   LuxuryAuto that = (LuxuryAuto) o;

   if (manufactureYear != that.manufactureYear) return false;
   return dollarPrice == that.dollarPrice;
}

@Override
public int hashCode() {
   int result = model == null ? 0 : model.hashCode();
   result = 31 * result + manufactureYear;
   result = 31 * result + dollarPrice;
   return result;
}

equals()తరగతికి సంబంధించిన మా మరియు hashCode()పద్ధతులు ఇక్కడ ఉన్నాయి LuxuryAuto. పద్ధతి hashCode()మారలేదు, కానీ మేము పద్ధతి modelనుండి ఫీల్డ్‌ను తీసివేసాము equals(). equals()పద్ధతి రెండు వస్తువులను పోల్చినప్పుడు మోడల్ ఇకపై ఉపయోగించబడే లక్షణం కాదు . కానీ హాష్ కోడ్‌ను లెక్కించేటప్పుడు, ఆ ఫీల్డ్ ఇప్పటికీ పరిగణనలోకి తీసుకోబడుతుంది. ఫలితంగా మనకు ఏమి లభిస్తుంది? రెండు కార్లను రూపొందించి తెలుసుకుందాం!

public class Main {

   public static void main(String[] args) {

       LuxuryAuto ferrariGTO = new LuxuryAuto("Ferrari 250 GTO", 1963, 70000000);
       LuxuryAuto ferrariSpider = new LuxuryAuto("Ferrari 335 S Spider Scaglietti", 1963, 70000000);

       System.out.println("Are these two objects equal to each other?");
       System.out.println(ferrariGTO.equals(ferrariSpider));

       System.out.println("What are their hash codes?");
       System.out.println(ferrariGTO.hashCode());
       System.out.println(ferrariSpider.hashCode());
   }
}

Are these two objects equal to each other? 
true 
What are their hash codes? 
-1372326051 
1668702472

లోపం! equals()మరియు పద్ధతుల కోసం వేర్వేరు ఫీల్డ్‌లను ఉపయోగించడం ద్వారా hashCode(), మేము వారి కోసం ఏర్పాటు చేసిన ఒప్పందాలను ఉల్లంఘించాము! పద్ధతి ప్రకారం సమానంగా ఉండే రెండు వస్తువులు equals()తప్పనిసరిగా ఒకే హాష్ కోడ్‌ని కలిగి ఉండాలి. మేము వాటికి భిన్నమైన విలువలను పొందాము. ఇటువంటి లోపాలు ఖచ్చితంగా నమ్మశక్యం కాని పరిణామాలకు దారి తీయవచ్చు, ప్రత్యేకించి హాష్‌ని ఉపయోగించే సేకరణలతో పని చేస్తున్నప్పుడు. ఫలితంగా, మీరు ఓవర్‌రైడ్ చేసినప్పుడు equals()మరియు hashCode(), మీరు అదే ఫీల్డ్‌లను పరిగణించాలి. ఈ పాఠం చాలా పొడవుగా ఉంది, కానీ మీరు ఈ రోజు చాలా నేర్చుకున్నారు! :) ఇప్పుడు టాస్క్‌లను పరిష్కరించడానికి తిరిగి రావడానికి సమయం ఆసన్నమైంది!