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

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