குறிப்புகளை ஒப்பிடுதல்

1. ஒப்பீடுகள்

புரோகிராமர்கள் எல்லா நேரங்களிலும் வெவ்வேறு மாறிகளை ஒருவருக்கொருவர் ஒப்பிட வேண்டும். ஆனால், நீங்கள் ஏற்கனவே பார்த்தபடி, எல்லாம் அவ்வளவு எளிதல்ல.

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

சரங்களை ஒப்பிடுவது இன்னும் கடினம். எல்லாவற்றிற்கும் மேலாக, சரங்கள் பொருள்களாக இருப்பதால் இது ஏற்படுகிறது. மேலும் என்னவென்றால், புரோகிராமர்கள் பெரும்பாலும் சரம் ஒப்பீடு சூழ்நிலையைப் பொறுத்து கொஞ்சம் வித்தியாசமாக செல்ல விரும்புகிறார்கள்.

2. சரங்கள் நினைவகத்தை எவ்வாறு ஒழுங்கமைக்கப்படுகின்றன

நீங்கள் ஏற்கனவே பார்த்தபடி, சரங்கள் முழு எண்கள் மற்றும் உண்மையான எண்களை விட வித்தியாசமாக நினைவகத்தில் சேமிக்கப்படுகின்றன:

சரங்களைச் சேமிக்க இரண்டு நினைவக தொகுதிகள் பயன்படுத்தப்படுகின்றன: ஒரு தொகுதி உரையையே சேமிக்கிறது (அதன் அளவு உரையின் அளவைப் பொறுத்தது) இரண்டாவது தொகுதி (4 பைட்டுகள்) முதல் தொகுதியின் முகவரியைச் சேமிக்கிறது.

ஒரு அனுபவமிக்க புரோகிராமர் " String strமாறி ஒரு Stringபொருளைப் பற்றிய குறிப்பைச் சேமிக்கிறது.

3. ஒரு சரத்திற்கு குறிப்புகளை வழங்குதல்

நீங்கள் ஒரு சரம் மாறியை மற்றொரு சரம் மாறிக்கு ஒதுக்க வேண்டியிருக்கும் போது இந்த அணுகுமுறையின் நன்மைகள் தெளிவாகத் தெரியும். உதாரணமாக:

String text = "This is a very important message";
String message = text;

இதன் விளைவாக என்ன நினைவகம் இருக்கும் என்பது இங்கே:

இந்த வகையான அசைன்மென்ட் செயல்பாட்டிற்குப் பிறகு, Stringபொருள் இருந்த இடத்திலேயே இருக்கும், மேலும் அதன் முகவரி (பொருளின் குறிப்பு) மாறியில் நகலெடுக்கப்படும் message.

4. குறிப்புகள் மற்றும் பொருள்களுடன் பணிபுரிதல்

ஆனால் நீங்கள் ஒரு சரத்தை பெரிய எழுத்துக்கு (பெரிய எழுத்துகள்) மாற்ற முடிவு செய்தால், ஜாவா இயந்திரம் எல்லாவற்றையும் சரியாகச் செய்கிறது: நீங்கள் இரண்டு பொருள்களுடன் முடிவடையும் String, textமற்றும் messageமாறிகள் ஒவ்வொன்றும் அதன் சொந்த பொருளுக்கு குறிப்புகளைச் சேமிக்கும்.

உதாரணமாக:

String text = "This is a very important message";
String message = text.toUpperCase(); 

இதன் விளைவாக என்ன நினைவகம் இருக்கும் என்பது இங்கே:

toUpperCase()முறையானது அது அழைக்கப்படும் சரத்தை மாற்றாது என்பதை நினைவில் கொள்ளவும் . அதற்கு பதிலாக, இது ஒரு புதிய சரத்தை (புதிய பொருள்) உருவாக்குகிறது மற்றும் அதற்கு ஒரு குறிப்பை வழங்குகிறது.

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

உதாரணமாக:

String text = "10 20 40 80";
Scanner console = new Scanner(text);
int a = console.nextInt();
int b = console.nextInt();

Scannerவகுப்பு எவ்வாறு செயல்படுகிறது என்பதைப் பற்றி இங்கே மேலும் அறியலாம் .

இவை அனைத்தும் நினைவகத்தில் சேமிக்கப்படும்:

இந்த வழக்கில், ஒரு Stringபொருள் நினைவகத்தில் இருந்ததைப் போலவே உள்ளது - அது பற்றிய குறிப்புகள் மட்டுமே மாறி மாறிகளில் சேமிக்கப்படும்.

String5. பொருள்களுக்கான குறிப்புகளை ஒப்பிடுதல்

இறுதியாக, நாங்கள் வேடிக்கையான பகுதியை அடைந்துள்ளோம்: சரம் ஒப்பீடு.

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

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

String text = "Hi";
String message = text;
String s1 = text.toUpperCase();
String s2 = text.toUpperCase(); 

நினைவகத்தில் என்ன இருக்கும் என்பது இங்கே:

messageமற்றும் மாறிகள் textஒரே பொருளைக் குறிக்கும் (அதன் முகவரியைச் சேமிக்கவும்). ஆனால் s1மற்றும் s2மாறிகள் மிகவும் ஒத்த ஆனால் வேறுபட்ட பொருள்களின் குறிப்புகளை சேமிக்கின்றன.

குறியீட்டில் இந்த 4 மாறிகளை ஒப்பிட்டுப் பார்த்தால், பின்வரும் முடிவைப் பெறுவீர்கள்:

String text = "Hi";
String message = text;
String s1 = text.toUpperCase();
String s2 = text.toUpperCase();
System.out.println(text == message);
System.out.println(text == s1);
System.out.println(s1 == s2); 

true  // The addresses are equal
false // The addresses are different
false // The addresses are different