వస్తువులను పోల్చడం

1. జావాలోని వస్తువులను పోల్చడం

జావాలో, వస్తువులను రిఫరెన్స్ ద్వారా మరియు విలువ ద్వారా పోల్చవచ్చు.

సూచనలను పోల్చడం

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

Integer a = 5;
Integer b = a;
System.out.println(a == b);

true

విలువతో పోల్చడం

కానీ రెండు వేరియబుల్స్ ఒకేలా ఉండే రెండు విభిన్న వస్తువులను సూచించే పరిస్థితులను మీరు తరచుగా ఎదుర్కోవచ్చు. ఉదాహరణకు, ఒకే వచనాన్ని కలిగి ఉన్న రెండు వేర్వేరు స్ట్రింగ్‌ల వస్తువులు.

విభిన్న వస్తువులు ఒకేలా ఉన్నాయో లేదో తెలుసుకోవడానికి, equals()పద్ధతిని ఉపయోగించండి. ఉదాహరణకి:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);
System.out.println(a.equals(b));

false
true

పద్ధతి equalsతరగతికి పరిమితం కాదు String. ప్రతి తరగతికి అది ఉంది.

మీరు స్వంతంగా వ్రాసే తరగతులు కూడా, మరియు ఎందుకు ఇక్కడ ఉన్నాయి.

2. Objectతరగతి

జావాలోని అన్ని తరగతులు Objectతరగతిని వారసత్వంగా పొందుతాయి. జావా సృష్టికర్తలు ఈ విధానంతో ముందుకు వచ్చారు.

మరియు ఒక తరగతి తరగతిని వారసత్వంగా పొందినట్లయితే Object, అది తరగతి యొక్క అన్ని పద్ధతులను పొందుతుంది Object. మరియు ఇది వారసత్వం యొక్క ప్రధాన పరిణామం.

మరో మాటలో చెప్పాలంటే, ప్రతి తరగతికి తరగతి పద్ధతులు ఉంటాయి Object, వాటి కోడ్ వాటిని పేర్కొనకపోయినా.

ఈ వారసత్వ పద్ధతుల్లో వస్తువు పోలికకు సంబంధించిన పద్ధతులు ఉంటాయి. ఇవి equals()మరియు hashCode()పద్ధతులు.

class Person
{
   String name;
   int age;
}

class Person extends Object
{
   String name;
   int age;

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

   public int hashCode()
   {
      return address_of_object_in_memory; // This is the default implementation, but there may be a different implementation
   }
}

ఎగువ ఉదాహరణలో, మేము Personపేరు మరియు వయస్సు పారామితులతో ఒక సాధారణ తరగతిని సృష్టించాము, కానీ ఒకే పద్ధతిని కాదు. కానీ అన్ని తరగతులు Objectతరగతిని వారసత్వంగా పొందినందున, Personతరగతి స్వయంచాలకంగా రెండు పద్ధతులను కలిగి ఉంటుంది:

boolean equals(Object obj)

int hashCode()

ఇది ఖచ్చితంగా ప్రతి వస్తువు equalsపద్ధతిని కలిగి ఉంటుంది మరియు వివిధ రకాల వస్తువులను ఒకదానితో ఒకటి పోల్చవచ్చు. ఇటువంటి కోడ్ సంపూర్ణంగా కంపైల్ చేస్తుంది మరియు పని చేస్తుంది.

Integer a = 5;
String s = "Hello";
System.out.println(a.equals(s));
System.out.println(s.equals(a));

false
false

Object a = new Integer(5);
Object b = new Integer(5);
System.out.println(a.equals(b)) ;

true

3. equals()పద్ధతి

equals()తరగతి నుండి వారసత్వంగా పొందిన పద్ధతి , Objectప్రస్తుత వస్తువును పాస్ చేసిన వస్తువులతో పోల్చడానికి సరళమైన అల్గోరిథంను అమలు చేస్తుంది: ఇది కేవలం వస్తువులకు సూచనలను సరిపోల్చుతుంది.

Personమీరు పద్ధతిని కాల్ చేయడానికి బదులుగా వేరియబుల్‌లను సరిపోల్చినట్లయితే మీరు అదే ఫలితాన్ని పొందుతారు equals(). ఉదాహరణ:

Person a = new Person();
a.name = "Steve";

Person b = new Person();
b.name = "Steve";

System.out.println(a == b);
System.out.println(a.equals(b));

false
false

పద్ధతిని equalsపిలిచినప్పుడు a, ఇది వేరియబుల్‌లో నిల్వ చేయబడిన సూచనను వేరియబుల్‌లో aనిల్వ చేసిన సూచనతో సరిపోల్చుతుంది b.

అయితే, పోలిక తరగతికి భిన్నంగా పనిచేస్తుంది String. ఎందుకు?

ఎందుకంటే తరగతిని సృష్టించిన వ్యక్తులు పద్ధతి Stringయొక్క వారి స్వంత అమలును వ్రాసారు equals().

equals()పద్ధతి యొక్క అమలు

ఇప్పుడు తరగతిలో సమానమైన పద్ధతి యొక్క మన స్వంత అమలును వ్రాస్దాం Person. మేము 4 ప్రధాన కేసులను పరిశీలిస్తాము.

దృశ్యం 1 : పద్ధతిని పిలిచే అదే వస్తువు equalsపద్ధతికి కూడా పంపబడుతుంది equals. ప్రస్తుత వస్తువు మరియు ఆమోదించబడిన వస్తువు యొక్క సూచనలు సమానంగా ఉంటే, పద్ధతి తప్పనిసరిగా తిరిగి ఇవ్వాలి true. ఒక వస్తువు తనతో సమానం.

కోడ్‌లో ఇది ఇలా కనిపిస్తుంది:

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

   // The rest of the code of the equals method
}

దృశ్యం 2 : nullపద్ధతికి పంపబడింది equals— మనం పోల్చడానికి ఏమీ లేదు. పద్ధతి అని పిలువబడే వస్తువు ఖచ్చితంగా శూన్యం కాదు, కాబట్టి మనం ఈ సందర్భంలో equalsతిరిగి రావాలి .false

కోడ్‌లో ఇది ఇలా కనిపిస్తుంది:

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

   if (obj == null)
      return false;

   // The rest of the code of the equals method
}

దృష్టాంతం 3 : ఒక వస్తువు కాని ఒక వస్తువుకు సంబంధించిన సూచన Personపద్ధతికి పంపబడుతుంది equals. Personవస్తువు కాని వస్తువుతో సమానమా Person? Personతరగతి డెవలపర్‌కి అతను లేదా ఆమె ఎలా కావాలో నిర్ణయించుకోవాల్సిన ప్రశ్న .

కానీ సాధారణంగా వస్తువులు సమానంగా పరిగణించబడాలంటే ఒకే తరగతికి చెందినవిగా ఉండాలి. అందువల్ల, తరగతిలోని వస్తువు కాకుండా ఏదైనా Personమా సమాన పద్ధతికి పాస్ అయినట్లయితే, మేము ఎల్లప్పుడూ తిరిగి వస్తాము false. మీరు వస్తువు యొక్క రకాన్ని ఎలా తనిఖీ చేయవచ్చు? అది నిజం — instanceofఆపరేటర్‌ని ఉపయోగించడం ద్వారా.

మా కొత్త కోడ్ ఎలా ఉంటుందో ఇక్కడ ఉంది:

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

   if (obj == null)
      return false;

   if (!(obj instanceof Person))
      return false;

   // The rest of the code of the equals method
}

Person4. రెండు వస్తువులను పోల్చడం

మనం దేనితో ముగించాము? మేము పద్ధతి ముగింపుకు చేరుకున్నట్లయితే, మనకు Personలేని వస్తువు సూచన ఉంది null. కాబట్టి మేము దానిని a గా మారుస్తాము Personమరియు రెండు వస్తువుల సంబంధిత అంతర్గత డేటాను సరిపోల్చండి. మరియు అది మా నాల్గవ దృశ్యం .

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

   if (obj == null)
      return false;

   if (!(obj instanceof Person))
      return false;

   Person person = (Person) obj;

   // The rest of the code of the equals method
}

మరియు మీరు రెండు వస్తువులను ఎలా పోల్చాలి Person? వారు ఒకే పేరు ( name) మరియు వయస్సు ( age) కలిగి ఉంటే వారు సమానంగా ఉంటారు. చివరి కోడ్ ఇలా కనిపిస్తుంది:

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

   if (obj == null)
      return false;

   if (!(obj instanceof Person))
      return false;

   Person person = (Person) obj;

   return this.name == person.name && this.age == person.age;
}

అయితే అంతే కాదు.

మొదట, పేరు ఫీల్డ్ a String, కాబట్టి మీరు పద్ధతిని కాల్ చేయడం ద్వారా పేరు ఫీల్డ్‌ను సరిపోల్చాలి equals.

this.name.equals(person.name)

రెండవది, nameఫీల్డ్ కావచ్చు null: ఆ సందర్భంలో, మీరు equalsదానిపై కాల్ చేయలేరు. దీని కోసం మీకు అదనపు చెక్ అవసరం null:

this.name != null && this.name.equals(person.name)

nullరెండు వస్తువులలో పేరు ఫీల్డ్ ఉంటే Person, పేర్లు ఇప్పటికీ సమానంగా ఉంటాయి.

నాల్గవ దృశ్యం కోసం కోడ్ ఇలా ఉండవచ్చు:

Person person = (Person) obj;

if (this.age != person.age)
   return false;

if (this.name == null)
   return person.name == null;

return this.name.equals(person.name);

5. hashCode()పద్ధతి

రెండు వస్తువుల యొక్క అన్ని ఫీల్డ్‌ల యొక్క వివరణాత్మక పోలికను నిర్వహించడానికి ఉద్దేశించిన పద్ధతితో పాటు equals, ఖచ్చితమైన కానీ చాలా శీఘ్ర పోలిక కోసం ఉపయోగించగల మరొక పద్ధతి ఉంది: hashCode().

మీరు వేలకొద్దీ పదాల జాబితాను అక్షర క్రమంలో క్రమబద్ధీకరిస్తున్నారని ఊహించుకోండి మరియు మీరు పదాల జతలను పదేపదే సరిపోల్చాలి. మరియు పదాలు చాలా పొడవుగా ఉంటాయి, ఇందులో చాలా అక్షరాలు ఉంటాయి. సాధారణంగా చెప్పాలంటే, అటువంటి పోలిక చాలా కాలం పడుతుంది.

కానీ అది వేగవంతం చేయవచ్చు. మనకు వేర్వేరు అక్షరాలతో ప్రారంభమయ్యే పదాలు ఉన్నాయని అనుకుందాం - అవి భిన్నంగా ఉన్నాయని వెంటనే స్పష్టమవుతుంది. కానీ అవి ఒకే అక్షరాలతో ప్రారంభమైతే, ఫలితం ఎలా ఉంటుందో మనం ఇంకా చెప్పలేము: పదాలు సమానంగా లేదా భిన్నంగా ఉండవచ్చు.

పద్ధతి hashCode()ఇదే సూత్రాన్ని ఉపయోగించి పనిచేస్తుంది. మీరు దానిని ఒక వస్తువుపై కాల్ చేస్తే, అది కొంత సంఖ్యను అందిస్తుంది - పదంలోని మొదటి అక్షరానికి సారూప్యంగా ఉంటుంది. ఈ సంఖ్య క్రింది లక్షణాలను కలిగి ఉంది:

• ఒకేలాంటి వస్తువులు ఎల్లప్పుడూ ఒకే హ్యాష్‌కోడ్‌ని కలిగి ఉంటాయి
• వేర్వేరు వస్తువులు ఒకే హ్యాష్‌కోడ్‌ను కలిగి ఉండవచ్చు లేదా వాటి హ్యాష్‌కోడ్‌లు భిన్నంగా ఉండవచ్చు
• వస్తువులు వేర్వేరు హ్యాష్‌కోడ్‌లను కలిగి ఉంటే, ఆ వస్తువులు ఖచ్చితంగా భిన్నంగా ఉంటాయి

దీన్ని మరింత స్పష్టంగా చేయడానికి, పదాల పరంగా ఈ లక్షణాలను రీఫ్రేమ్ చేద్దాం:

• ఒకే విధమైన పదాలు ఎల్లప్పుడూ ఒకే మొదటి అక్షరాలను కలిగి ఉంటాయి.
• వేర్వేరు పదాలు ఒకే మొదటి అక్షరాలను కలిగి ఉండవచ్చు లేదా వాటి మొదటి అక్షరాలు భిన్నంగా ఉండవచ్చు
• పదాలు వేర్వేరు మొదటి అక్షరాలను కలిగి ఉంటే, పదాలు ఖచ్చితంగా భిన్నంగా ఉంటాయి

వస్తువుల పోలికను వేగవంతం చేయడానికి చివరి ఆస్తి ఉపయోగించబడుతుంది:

మొదట, రెండు వస్తువుల హ్యాష్‌కోడ్‌లు లెక్కించబడతాయి. ఈ హ్యాష్‌కోడ్‌లు భిన్నంగా ఉంటే, వస్తువులు ఖచ్చితంగా భిన్నంగా ఉంటాయి మరియు వాటిని మరింత పోల్చాల్సిన అవసరం లేదు.

హ్యాష్‌కోడ్‌లు ఒకేలా ఉంటే, మనం ఇప్పటికీ ఈక్వల్స్ పద్ధతిని ఉపయోగించి వస్తువులను పోల్చాలి.

6. కోడ్‌లో ఒప్పందాలు

పైన వివరించిన ప్రవర్తన తప్పనిసరిగా జావాలోని అన్ని తరగతులచే అమలు చేయబడాలి. సంకలనం సమయంలో, వస్తువులు సరిగ్గా సరిపోలుతున్నాయో లేదో తనిఖీ చేయడానికి మార్గం లేదు.

జావా ప్రోగ్రామర్లు సార్వత్రిక ఒప్పందాన్ని కలిగి ఉంటారు, వారు ఈక్విల్స్() పద్ధతి యొక్క వారి స్వంత అమలును వ్రాసి, తద్వారా ప్రామాణిక అమలును (తరగతిలో) భర్తీ చేస్తే , వారు పైన పేర్కొన్న నియమాలు ఉండే విధంగా పద్ధతి Objectయొక్క వారి స్వంత అమలును కూడా వ్రాయాలి. hashCode()సంతృప్తి చెందారు.

ఈ ఏర్పాటును ఒప్పందం అంటారు .

మీరు మీ తరగతిలో పద్ధతిని మాత్రమే అమలు చేస్తే equals()లేదా hashCode()మీరు మాత్రమే ఒప్పందాన్ని ఉల్లంఘిస్తారు (మీరు ఒప్పందాన్ని ఉల్లంఘించారు). ఇది చేయవద్దు.

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

అంటే మీరు మీ స్వంత తరగతికి ఒక equalsపద్ధతిని ఇచ్చినప్పటికీ, మీరు మీ స్వంత పద్ధతిని వ్రాయకపోయినా hashCode()లేదా మీరు దానిని తప్పుగా అమలు చేసినా, మీ వస్తువులతో సేకరణలు సరిగ్గా పని చేయకపోవచ్చు.

ఉదాహరణకు, మీరు జాబితాకు ఒక వస్తువును జోడించి, ఆపై contains()పద్ధతిని ఉపయోగించి దాని కోసం శోధించవచ్చు, కానీ సేకరణ మీ వస్తువును కనుగొనలేకపోవచ్చు.