பொருட்களை ஒப்பிடுதல்

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ஒப்பிடுகிறது .ab

இருப்பினும், வகுப்பிற்கு ஒப்பீடு வித்தியாசமாக வேலை செய்கிறது 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;
}

ஆனால் அதெல்லாம் இல்லை.

முதலில், பெயர் புலம் ஒரு 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(), ஆனால் சேகரிப்பு உங்கள் பொருளைக் கண்டுபிடிக்காமல் போகலாம்.