ஜாவாவில் சரம் மற்றும் சமமான ஒப்பீடுகளை ஒப்பிடுக

வணக்கம்! இன்று நாம் ஒரு மிக முக்கியமான மற்றும் சுவாரஸ்யமான தலைப்பைப் பற்றி பேசுவோம், அதாவது, பொருள்களுடன் பொருட்களை ஒப்பிடுவது (சரங்கள் மற்றும் சமங்களை ஒப்பிடுக). எனவே ஜாவாவில், A ஆப்ஜெக்ட் B க்கு சமமாக எப்போது இருக்கும் ? ஒரு உதாரணத்தை எழுத முயற்சிப்போம்:

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);
   }
}

கன்சோல் வெளியீடு: தவறான காத்திரு, நிறுத்து. ஏன் இந்த இரண்டு கார்களும் சமமாக இல்லை? நாங்கள் அவர்களுக்கு அதே பண்புகளை வழங்கினோம், ஆனால் ஒப்பீட்டின் முடிவு தவறானது. பதில் எளிது. == ஆபரேட்டர் பொருள் குறிப்புகளை ஒப்பிடுகிறது, பொருள் பண்புகளை அல்ல. இரண்டு பொருள்கள் ஒரே மாதிரியான மதிப்புகளுடன் 500 புலங்களைக் கொண்டிருக்கலாம், ஆனால் அவற்றை ஒப்பிடுவது தவறானதாக இருக்கும். எல்லாவற்றிற்கும் மேலாக, கார்1 மற்றும் கார்2 குறிப்புகள்இரண்டு வெவ்வேறு பொருள்களை, அதாவது இரண்டு வெவ்வேறு முகவரிகளுக்குச் சுட்டி. நீங்கள் மக்களை ஒப்பிடும் சூழ்நிலையை கற்பனை செய்து பாருங்கள். நிச்சயமாக, உலகில் எங்கோ ஒரு நபர் உங்கள் அதே பெயர், கண் நிறம், வயது, உயரம், முடி நிறம் போன்றவற்றைப் பகிர்ந்துகொள்கிறார். அது உங்களை பல விஷயங்களில் ஒத்திருக்கிறது, ஆனால் நீங்கள் இன்னும் இரட்டையர்கள் அல்ல - நீங்கள் வெளிப்படையாக இல்லை அதே நபர். இரண்டு பொருட்களை ஒப்பிட்டுப் பார்க்கும்போது == ஆபரேட்டர் தோராயமாக இதே தர்க்கத்தைப் பயன்படுத்துகிறது. ஆனால் வேறு தர்க்கத்தைப் பயன்படுத்த உங்கள் நிரல் தேவைப்பட்டால் என்ன செய்வது? உதாரணமாக, உங்கள் நிரல் டிஎன்ஏ பகுப்பாய்வு செய்கிறது என்று வைத்துக்கொள்வோம். இது இரண்டு நபர்களின் மரபணு குறியீட்டை ஒப்பிட்டு, அவர்கள் இரட்டையர்களா என்பதை தீர்மானிக்கிறது.

public class Man {

   int geneticCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.geneticCode = 1111222233;

       Man man2 = new Man();
       man2.geneticCode = 1111222233;

       System.out.println(man1 == man2);
   }
}

கன்சோல் வெளியீடு: தவறானது அதே தருக்க முடிவைப் பெறுகிறோம் (ஏனென்றால் நாங்கள் அதிகம் மாறவில்லை), ஆனால் இப்போது அந்த தர்க்கம் நல்லதல்ல! எல்லாவற்றிற்கும் மேலாக, நிஜ வாழ்க்கையில், டிஎன்ஏ பகுப்பாய்வானது நமக்கு முன்னால் இரட்டையர்கள் நிற்கிறது என்பதற்கு 100% உத்தரவாதத்தை அளிக்க வேண்டும். ஆனால் நமது புரோகிராம் மற்றும் == ஆபரேட்டர் நமக்கு எதிர்மாறாக கூறுகின்றன. இந்த நடத்தையை எப்படி மாற்றி, டிஎன்ஏ பொருந்தும்போது நிரல் சரியான முடிவை வெளியிடுகிறது என்பதை உறுதிப்படுத்துவது எப்படி? ஜாவாவிற்கு ஒரு சிறப்பு முறை உள்ளது: சமம்() . நாம் முன்பு விவாதித்த toString() முறையைப் போலவே , சமம்() என்பது பொருள் வகுப்பைச் சேர்ந்தது - ஜாவாவில் உள்ள மிக முக்கியமான வகுப்பு, மற்ற அனைத்து வகுப்புகளும் பெறப்பட்ட வகுப்பாகும். ஆனால் சமம்()எங்கள் நிரலின் நடத்தையை தானாகவே மாற்றாது:

public class Man {

   String geneticCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.geneticCode = "111122223333";

       Man man2 = new Man();
       man2.geneticCode = "111122223333";

       System.out.println(man1.equals(man2));
   }
}

கன்சோல் வெளியீடு: தவறானது அதே முடிவுதான், இந்த முறை எதற்காகத் தேவை? :/ எல்லாம் எளிது. இங்குள்ள சிக்கல் என்னவென்றால், இந்த முறையை நாம் தற்போது ஆப்ஜெக்ட் வகுப்பில் செயல்படுத்தி வருகிறோம் . நாம் பொருள் வகுப்பின் குறியீட்டிற்குள் சென்று முறையின் செயல்படுத்தலைப் பார்த்தால், நாம் பார்ப்பது இதுதான்:

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

நிரலின் நடத்தை மாறாததற்கு இதுவே காரணம்! அதே == ஆபரேட்டர் (குறிப்புகளை ஒப்பிடும்) பொருள் வகுப்பின் சமம்() முறையில் பயன்படுத்தப்படுகிறது . ஆனால் இந்த முறையின் தந்திரம் என்னவென்றால், நாம் அதை மீற முடியும். மேலெழுதுதல் என்பது, எங்கள் மேன் வகுப்பில் உங்கள் சொந்த சம() முறையை எழுதுவது , நமக்குத் தேவையான நடத்தையைக் கொடுப்பதாகும்! தற்போது, ​​man1.equals(man2) என்பது man1 == man2 க்கு சமமானதாக இருப்பது எங்களுக்குப் பிடிக்கவில்லை . இந்த சூழ்நிலையில் நாம் என்ன செய்வோம்:

public class Man { 

   int dnaCode; 

   public boolean equals(Man man) { 
       return this.dnaCode ==  man.dnaCode; 

   } 

   public static void main(String[] args) { 

       Man man1 = new Man(); 
       man1.dnaCode = 1111222233; 

       Man man2 = new Man(); 
       man2.dnaCode = 1111222233; 

       System.out.println(man1.equals(man2)); 

   } 
} 

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

ஜாவாவில் சரங்களை ஒப்பிடுதல்

எல்லாவற்றிலிருந்தும் சரம் ஒப்பீடுகளை நாம் ஏன் தனித்தனியாகக் கருதுகிறோம்? உண்மை என்னவென்றால், நிரலாக்கத்தில் சரங்கள் அவற்றின் சொந்த உரிமையில் ஒரு பாடமாகும். முதலில், நீங்கள் இதுவரை எழுதப்பட்ட அனைத்து ஜாவா நிரல்களையும் எடுத்துக் கொண்டால், அவற்றில் உள்ள பொருட்களில் 25% சரங்களாக இருப்பதைக் காணலாம். எனவே இந்த தலைப்பு மிகவும் முக்கியமானது. இரண்டாவதாக, சரங்களை ஒப்பிடும் செயல்முறை உண்மையில் மற்ற பொருட்களிலிருந்து மிகவும் வேறுபட்டது. ஒரு எளிய உதாரணத்தைக் கவனியுங்கள்:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2);
   }
}

கன்சோல் வெளியீடு: தவறு ஆனால் நாம் ஏன் பொய்யானோம்? எல்லாவற்றிற்கும் மேலாக, சரங்கள் ஒரே மாதிரியானவை, வார்த்தைக்கு வார்த்தை :/ நீங்கள் காரணத்தை யூகித்திருக்கலாம்: == ஆபரேட்டர் குறிப்புகளை ஒப்பிடுவதால் தான் ! தெளிவாக, s1 மற்றும் s2 நினைவகத்தில் வெவ்வேறு முகவரிகள் உள்ளன. நீங்கள் அதை நினைத்தால், எங்கள் உதாரணத்தை மீண்டும் உருவாக்குவோம்:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = "CodeGym is the best website for learning Java!";
       System.out.println(s1 == s2);
   }
}

இப்போது எங்களிடம் மீண்டும் இரண்டு குறிப்புகள் உள்ளன, ஆனால் விளைவு நேர் எதிரானது: கன்சோல் வெளியீடு: உண்மை உதவியற்ற முறையில் குழப்பமா? என்ன நடக்கிறது என்பதைக் கண்டுபிடிப்போம். == ஆபரேட்டர் உண்மையில் நினைவக முகவரிகளை ஒப்பிடுகிறது. இது எப்போதும் உண்மை மற்றும் நீங்கள் சந்தேகிக்க தேவையில்லை. அதாவது s1 == s2 உண்மை எனத் திரும்பினால், இந்த இரண்டு சரங்களும் ஒரே முகவரியைக் கொண்டிருக்கும். மேலும் இது உண்மைதான்! சரங்களை சேமிப்பதற்கான நினைவகத்தின் ஒரு சிறப்புப் பகுதியை உங்களுக்கு அறிமுகப்படுத்த வேண்டிய நேரம் இது: சரம் குளம் ஸ்ட்ரிங் பூல் என்பது உங்கள் நிரலில் நீங்கள் உருவாக்கும் அனைத்து சர மதிப்புகளையும் சேமிப்பதற்கான ஒரு பகுதி. அது ஏன் உருவாக்கப்பட்டது? நாம் முன்பு கூறியது போல், சரங்கள் அனைத்து பொருட்களின் பெரும் சதவீதத்தை குறிக்கின்றன. எந்த பெரிய நிரலும் நிறைய சரங்களை உருவாக்குகிறது. நினைவகத்தை சேமிப்பதற்காக ஸ்ட்ரிங் பூல் உருவாக்கப்பட்டது: சரங்கள் அங்கு வைக்கப்பட்டு, பின்னர் உருவாக்கப்பட்ட சரங்கள் நினைவகத்தின் அதே பகுதியைக் குறிக்கும்-ஒவ்வொரு முறையும் கூடுதல் நினைவகத்தை ஒதுக்க வேண்டிய அவசியமில்லை. ஒவ்வொரு முறையும் நீங்கள் String = "........" என்று எழுதும் போது , ​​சரம் பூலில் ஒரே மாதிரியான சரம் உள்ளதா என நிரல் சரிபார்க்கிறது. இருந்தால், புதிய சரம் உருவாக்கப்படாது. புதிய குறிப்பு, சரம் குளத்தில் (ஒரே மாதிரியான சரம் அமைந்துள்ள இடத்தில்) அதே முகவரியைக் குறிக்கும். எனவே நாங்கள் எழுதியபோது

String s1 = "CodeGym is the best website for learning Java!";

String s2 = "CodeGym is the best website for learning Java!";

s2 அதே இடத்தில் s1 புள்ளிகள் . முதல் ஸ்டேட்மெண்ட் சரம் பூலில் ஒரு புதிய சரத்தை உருவாக்குகிறது. இரண்டாவது கூற்று s1 போன்ற நினைவகத்தின் அதே பகுதியைக் குறிக்கிறது . நீங்கள் மற்றொரு 500 ஒத்த சரங்களை உருவாக்கலாம் மற்றும் முடிவு மாறாது. ஒரு நிமிடம் பொறுங்கள். அது உண்மை என்றால், இந்த உதாரணம் ஏன் இதற்கு முன் வேலை செய்யவில்லை?

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2);
   }
}

உங்கள் உள்ளுணர்வு ஏற்கனவே காரணத்தைச் சொல்லிவிட்டதாக நினைக்கிறேன் =) மேலும் படிக்கும் முன் யூகிக்க முயற்சிக்கவும். இந்த இரண்டு சரங்களும் வெவ்வேறு வழிகளில் அறிவிக்கப்பட்டிருப்பதைக் காணலாம். ஒன்று புதிய ஆபரேட்டருடன், மற்றொன்று அது இல்லாமல். இதோ காரணம். ஒரு பொருளை உருவாக்க புதிய ஆபரேட்டர் பயன்படுத்தப்படும் போது , ​​அது பொருளுக்கு ஒரு புதிய நினைவக பகுதியை வலுக்கட்டாயமாக ஒதுக்குகிறது. புதியதைப் பயன்படுத்தி உருவாக்கப்பட்ட ஒரு சரம் சரம் பூலில் முடிவடையாது - அதன் உரை சரம் பூலில் உள்ள ஒரு சரத்துடன் சரியாகப் பொருந்தினாலும், அது ஒரு தனி பொருளாக மாறும். அதாவது, பின்வரும் குறியீட்டை எழுதினால்:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = "CodeGym is the best website for learning Java!";
       String s3 = new String("CodeGym is the best website for learning Java!");
   }
}

நினைவகத்தில், இது போல் தெரிகிறது: ஒவ்வொரு முறையும் நீங்கள் புதிய பொருளைப் பயன்படுத்தி புதிய பொருளை உருவாக்கும் போது , ​​புதிய சரத்திற்குள் உள்ள உரை ஒரே மாதிரியாக இருந்தாலும், புதிய நினைவகப் பகுதி ஒதுக்கப்படும்! == ஆபரேட்டரைக் கண்டுபிடித்துவிட்டதாகத் தெரிகிறது . ஆனால் எங்கள் புதிய அறிமுகமான சமமான () முறை பற்றி என்ன?

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1.equals(s2));
   }
}

கன்சோல் வெளியீடு: உண்மையான சுவாரஸ்யமானது. s1 மற்றும் s2 ஆகியவை நினைவகத்தில் வெவ்வேறு பகுதிகளை சுட்டிக்காட்டுகின்றன என்பதில் நாங்கள் உறுதியாக உள்ளோம் . ஆனால் சமம் () முறை இன்னும் சமம் என்று சொல்கிறது. ஏன்? நாம் எப்படி வேண்டுமானாலும் பொருள்களை ஒப்பிட்டுப் பார்ப்பதற்கு சமம்() முறையை மேலெழுதலாம் என்று முன்பு கூறியது நினைவிருக்கிறதா ? அதைத்தான் அவர்கள் சரம் வகுப்பில் செய்திருக்கிறார்கள். இது சமம் ()முறை. குறிப்புகளை ஒப்பிடுவதற்குப் பதிலாக, இது சரங்களில் உள்ள எழுத்துக்களின் வரிசையை ஒப்பிடுகிறது. உரை ஒரே மாதிரியாக இருந்தால், அவை எவ்வாறு உருவாக்கப்பட்டன அல்லது அவை எங்கு சேமிக்கப்படுகின்றன என்பது முக்கியமல்ல: சரம் பூலில் அல்லது நினைவகத்தின் தனிப் பகுதியில். ஒப்பீட்டின் முடிவு உண்மையாக இருக்கும். மூலம், ஜாவா கேஸ்-இன்சென்சிட்டிவ் சரம் ஒப்பீடுகளைச் செய்ய உங்களை அனுமதிக்கிறது. பொதுவாக, சரங்களில் ஒன்றில் அனைத்து பெரிய எழுத்துக்களும் இருந்தால், ஒப்பீட்டின் முடிவு தவறானதாக இருக்கும்:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CODEGYM IS THE BEST WEBSITE FOR LEARNING JAVA!");
       System.out.println(s1.equals(s2));
   }
}

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

public class Main {

   public static void main(String[] args) {

       String address1 = "2311 Broadway Street, San Francisco";
       String address2 = new String("2311 BROADWAY STREET, SAN FRANCISCO");
       System.out.println(address1.equalsIgnoreCase(address2));
   }
}

இந்த விஷயத்தில், நாங்கள் வெளிப்படையாக அதே முகவரியைப் பற்றி பேசுகிறோம், எனவே equalsIgnoreCase() முறையைப் பயன்படுத்துவது அர்த்தமுள்ளதாக இருக்கிறது .

String.intern() முறை

சரம் வகுப்பில் இன்னும் ஒரு தந்திரமான முறை உள்ளது: intern() ; இன்டர்ன் () முறை சரம் பூலுடன் நேரடியாக வேலை செய்கிறது. நீங்கள் இன்டர்ன்() முறையை சில சரத்தில் அழைத்தால் :

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

புதியதைப் பயன்படுத்தி பெறப்பட்ட சரம் குறிப்பில் intern() முறையைப் பயன்படுத்திய பிறகு , சரம் பூலில் இருந்து ஒரு சரம் குறிப்புடன் ஒப்பிடுவதற்கு == ஆபரேட்டரைப் பயன்படுத்தலாம் .

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2.intern());
   }
}

கன்சோல் வெளியீடு: உண்மை இந்த சரங்களை முன்பு இன்டர்ன்() இல்லாமல் ஒப்பிட்டுப் பார்த்தபோது , ​​முடிவு தவறானது. இப்போது இன்டர்ன்() முறையானது "கோட்ஜிம் ஜாவாவைக் கற்க சிறந்த தளமா!" என்பதைச் சரிபார்க்கிறது. சரம் குளத்தில் உள்ளது. நிச்சயமாக, இது: நாங்கள் அதை உருவாக்கியுள்ளோம்

String s1 = "CodeGym is the best website for learning Java!";

s1 மற்றும் s2.intern() வழங்கிய குறிப்பு நினைவகத்தின் அதே பகுதியைச் சுட்டிக்காட்டுகிறதா என்பதை நாங்கள் சரிபார்க்கிறோம் . நிச்சயமாக, அவர்கள் செய்கிறார்கள் :) சுருக்கமாக, இந்த முக்கியமான விதியை மனப்பாடம் செய்து பயன்படுத்தவும்: சரங்களை ஒப்பிடுவதற்கு எப்போதும் சமம்() முறையைப் பயன்படுத்தவும்! சரங்களை ஒப்பிடும் போது, ​​குறிப்புகள், நினைவகப் பகுதிகள் அல்லது வேறு எதையும் விட அவற்றின் எழுத்துக்களை ஒப்பிட்டுப் பார்ப்பதை எப்போதும் குறிக்கிறோம். சமம் () முறை உங்களுக்குத் தேவையானதைச் சரியாகச் செய்கிறது. நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்