స్ట్రింగ్ యొక్క అంతర్గత పనితీరు మరియు సబ్‌స్ట్రింగ్ పద్ధతి

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ."

"నేను మీకు సబ్‌స్ట్రింగ్‌ల గురించి చెప్పబోతున్నాను. సబ్‌స్ట్రింగ్ అనేది స్ట్రింగ్‌లో ఒక భాగం. మరియు స్ట్రింగ్‌లపై చేసే అత్యంత సాధారణ ఆపరేషన్ (అనేక స్ట్రింగ్‌లను కలిపిన తర్వాత) సబ్‌స్ట్రింగ్‌ను పొందడం."

7) నేను స్ట్రింగ్‌లో భాగాన్ని ఎలా పొందగలను?

"సబ్‌స్ట్రింగ్ పద్ధతి స్ట్రింగ్‌లో కొంత భాగాన్ని అందిస్తుంది. ఈ పద్ధతికి రెండు వెర్షన్‌లు ఉన్నాయి."

"మొదటి సంస్కరణ సూచికలను ప్రారంభించడం మరియు ముగించడం ద్వారా పేర్కొన్న సబ్‌స్ట్రింగ్‌ను అందిస్తుంది. కానీ ముగింపు సూచికలో అక్షరం చేర్చబడలేదు! మీరు 1 మరియు 3 సంఖ్యలను పాస్ చేస్తే, సబ్‌స్ట్రింగ్ రెండవ మరియు మూడవ అక్షరాలను మాత్రమే కలిగి ఉంటుంది (సూచీలు ప్రారంభమైనట్లు గుర్తుంచుకోండి 0 తో)."

"రెండవ వెర్షన్ పాస్ చేసిన సూచిక నుండి స్ట్రింగ్ చివరి వరకు సబ్‌స్ట్రింగ్‌ను అందిస్తుంది."

String substring(int beginIndex, int endIndex)

String s = "Good news, everyone!";
s = s.substring(1,6);

s == "ood n";

String substring(int beginIndex)

String s = "Good news, everyone!";
s = s.substring(1);

"అది చాలా సులభం. ధన్యవాదాలు, ఎల్లీ."

"నేను మీకు స్ట్రింగ్ ఆబ్జెక్ట్‌ల అంతర్గత పనితీరును కూడా వివరించబోతున్నాను."

"మీకు బహుశా ఇప్పటికే తెలిసినట్లుగా, స్ట్రింగ్ అనేది మార్పులేని తరగతి. మరియు అది మనకు ఎలాంటి ప్రయోజనాలను ఇస్తుంది? ఇది జరిగినప్పుడు, సబ్‌స్ట్రింగ్‌ను పొందగల సామర్థ్యం కీలక ప్రయోజనాల్లో ఒకటి. అయితే ముందుగా మొదటిది."

"అంతర్గతంగా, స్ట్రింగ్ ఆబ్జెక్ట్ అక్షరాల శ్రేణిని కలిగి ఉంటుంది, ఇది ఊహించడం అంత కష్టం కాదు. కానీ ఇది మరో రెండు వేరియబుల్స్‌ను కూడా నిల్వ చేస్తుంది: శ్రేణిలోని మొదటి అక్షరం యొక్క సూచిక మరియు అక్షర గణన. ఇప్పుడు నేను మీకు చెప్తాను. కోసం ఉపయోగిస్తారు."

"మేము సబ్‌స్ట్రింగ్ పద్ధతిని ఉపయోగించి సబ్‌స్ట్రింగ్‌ను సృష్టించినప్పుడు , కొత్త స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించబడుతుంది."

"కానీ, కొత్త అక్షర శ్రేణికి సూచనను నిల్వ చేయడానికి బదులుగా, ఆబ్జెక్ట్ పాత శ్రేణికి సూచనను అలాగే దానితో అనుబంధించబడిన అసలు అక్షర శ్రేణి యొక్క భాగాన్ని గుర్తించడానికి ఉపయోగించే రెండు వేరియబుల్‌లను నిల్వ చేస్తుంది."

"నాకు ఏదీ అర్థం కాలేదు."

"ఒక సబ్‌స్ట్రింగ్ సృష్టించబడినప్పుడు, అక్షర శ్రేణి కొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌కు కాపీ చేయబడదు. బదులుగా, రెండు వస్తువులు అసలు అక్షర శ్రేణికి సూచనను నిల్వ చేస్తాయి. కానీ! రెండవ వస్తువు రెండు వేరియబుల్‌లను కూడా నిల్వ చేస్తుంది: దాని ప్రారంభ సూచిక శ్రేణిలో మరియు సబ్‌స్ట్రింగ్‌కు చెందిన అక్షరాల సంఖ్య."

"చూడండి:"

String s = "mama";

char[] value = {'m','a','m','a'};
offset = 0;
count = 4;

String s2 = s.substring(1);

char[] value = {'m','a','m','a'};
offset = 1;
count = 3;

String s3 = s.substring(1, 3);

char[] value = {'m','a','m','a'};
offset = 1;
count = 2;

"మూడు స్ట్రింగ్‌లు ఒకే చార్ శ్రేణికి సూచనను నిల్వ చేస్తాయి, కానీ అవి వాటికి సంబంధించిన మొదటి మరియు చివరి అక్షరాల సూచికను కూడా నిల్వ చేస్తాయి. లేదా మరింత ఖచ్చితంగా చెప్పాలంటే, మొదటి అక్షరం యొక్క సూచిక మరియు అక్షర గణన."

"అది ఇప్పుడు అర్ధమైంది."

"కాబట్టి, మీరు 10,000 అక్షరాల పొడవు గల స్ట్రింగ్‌ని తీసుకుంటే మరియు మీరు 10,000 సబ్‌స్ట్రింగ్‌లను సృష్టించినట్లయితే, ఈ సబ్‌స్ట్రింగ్‌లు చాలా తక్కువ మెమరీని ఉపయోగిస్తాయి, ఎందుకంటే అక్షర శ్రేణి డూప్లికేట్ చేయబడదు. ఈ స్ట్రింగ్‌లు, మీరు ఎక్కువగా ఉపయోగించాలని భావిస్తున్నారు. స్థలం, అక్షరాలా రెండు బైట్‌లను మాత్రమే తీసుకుంటుంది."

"కూల్!"

"అయితే మీరు స్ట్రింగ్‌లను సవరించగలిగితే మీరు అలా చేయగలరా?"

"లేదు, ఎవరైనా మొదటి స్ట్రింగ్‌ని మార్చవచ్చు, ఆపై దాని సబ్‌స్ట్రింగ్‌లన్నీ కూడా మారతాయి. వారు అలా ఎందుకు చేశారో ఇప్పుడు అర్థమైంది. అది నిజంగా చక్కని పరిష్కారం."

"నీకు నచ్చినందుకు నాకు సంతోషంగా ఉంది."