உள்ளடக்கம் மூலம் சரங்களை ஒப்பிடுதல்

1. சரங்களை ஒப்பிடுதல்

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

இதற்கு நமக்கு உதவ, ஜாவாவின் Stringவகுப்பில் முறை உள்ளது equals. அழைப்பது இதுபோல் தெரிகிறது:

string1.equals(string2)

trueசரங்கள் ஒரே மாதிரியாக இருந்தால், falseஅவை ஒரே மாதிரியாக இல்லாவிட்டால் இந்த முறை திரும்பும் .

உதாரணமாக:

String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s2.equals(s3));

// Hello
// HELLO
// HELLO

false // They are different
false // They are different
true // They are the same, even though the addresses are different

மேலும் உதாரணங்கள்:

"Hello".equals("HELLO")

String s = "Hello";
"Hello".equals(s);

String s = "Hel";
"Hello".equals(s + "lo");

String s = "H";
(s + "ello").equals(s + "ello");

2. கேஸ்-உணர்வற்ற சரம் ஒப்பீடு

கடைசி எடுத்துக்காட்டில், ஒப்பீடு பலனளிக்கிறது என்பதை நீங்கள் பார்த்தீர்கள் . உண்மையில், சரங்கள் சமமாக இல்லை. ஆனாலும்..."Hello".equals("HELLO")false

தெளிவாக, சரங்கள் சமமாக இல்லை. அவற்றின் உள்ளடக்கம் ஒரே எழுத்துக்களைக் கொண்டுள்ளது மற்றும் கடிதங்களின் விஷயத்தில் மட்டுமே வேறுபடுகிறது. அவற்றை ஒப்பிட்டு, கடிதங்களின் வழக்கைப் புறக்கணிக்க ஏதாவது வழி இருக்கிறதா? அதாவது, அதனால் விளைச்சல் ?"Hello".equals("HELLO")true

மேலும் இந்த கேள்விக்கான பதில் ஆம். ஜாவாவில், Stringவகைக்கு மற்றொரு சிறப்பு முறை உள்ளது: equalsIgnoreCase. அழைப்பது இதுபோல் தெரிகிறது:

string1.equalsIgnoreCase(string2)

முறையின் பெயர் தோராயமாக ஒப்பிட்டு ஆனால் புறக்கணிக்க என மொழிபெயர்க்கப்பட்டுள்ளது . முறையின் பெயரில் உள்ள எழுத்துக்களில் இரண்டு செங்குத்து கோடுகள் உள்ளன: முதலாவது சிறிய எழுத்து L, இரண்டாவது பெரிய எழுத்து i. அது உங்களை குழப்பி விடாதீர்கள்.

உதாரணமாக:

String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println(s2.equalsIgnoreCase(s3));  

// Hello
// HELLO
// HELLO

true
true
true

3. சரம் ஒப்பீடு உதாரணம்

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

Scanner console = new Scanner(System.in);
String a = console.nextLine();
String b = console.nextLine();
String result = a.equals(b) ? "Same" : "Different";
System.out.println(result);

4. சரம் ஒப்பீட்டின் சுவாரஸ்யமான நுணுக்கம்

நீங்கள் அறிந்திருக்க வேண்டிய முக்கியமான நுணுக்கம் ஒன்று உள்ளது.

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

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

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

நீங்கள் இங்கே ஒப்பிட்டுப் பார்த்தால் text == message, நீங்கள் பெறுவீர்கள் true. அதனால் ஆச்சரியப்பட வேண்டாம்.

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

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

அல்லது இது:

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

இந்த இரண்டு நிகழ்வுகளிலும், textமற்றும் messageமாறிகள் ஒரே உரையைக் கொண்ட வெவ்வேறு பொருள்களை சுட்டிக்காட்டுகின்றன.