"నమస్కారాలు, అమిగో!"
"హలో, రిషీ!"
"ఆసక్తికరమైనదాన్ని నేర్చుకోవడానికి మీకు ఇప్పుడు స్ట్రింగ్ల గురించి తగినంతగా తెలుసు. మరింత ప్రత్యేకంగా, స్ట్రింగ్ క్లాస్ని పోలి ఉండే కొత్త క్లాస్, కానీ సరిగ్గా అదే కాదు."
"సాధారణ స్ట్రింగ్లు ఎలా తగ్గుతాయో మరియు ఇతర స్ట్రింగ్-వంటి తరగతులు ఎందుకు అవసరమో నాకు పూర్తిగా స్పష్టంగా తెలియనప్పటికీ, చమత్కారంగా అనిపిస్తుంది."
"తీగలు జావాలో మార్పులేని వస్తువులు అనే వాస్తవంతో ప్రారంభిద్దాం."
"అది ఎలా? నేను మర్చిపోయాను ... లేదా నేను ప్రారంభించాలని నాకు ఎప్పుడూ తెలియదు ..."
"మారలేని వస్తువులు అవి సృష్టించబడిన తర్వాత వాటి స్థితిని మార్చలేనివి అని నేను మీకు గుర్తు చేస్తాను."
"ఆహ్... జావాలో తీగలు ఎందుకు మారవు?"
"ఇది స్ట్రింగ్ క్లాస్ను అత్యంత ఆప్టిమైజ్ చేయడానికి మరియు ప్రతిచోటా ఉపయోగించడానికి అనుమతించడానికి చేయబడింది. ఉదాహరణకు, HashMap సేకరణలో కీలుగా ఉపయోగించడానికి మార్పులేని రకాలు మాత్రమే సిఫార్సు చేయబడ్డాయి .
"అయినప్పటికీ, స్ట్రింగ్ క్లాస్ మార్చగలిగేలా ప్రోగ్రామర్లు మరింత సౌకర్యవంతంగా భావించే సందర్భాలు తరచుగా తలెత్తుతాయి. వారు ఒక పద్ధతిని పిలిచిన ప్రతిసారీ కొత్త సబ్స్ట్రింగ్ను సృష్టించని తరగతిని కోరుకుంటారు."
"అయితే అది దేనికి మంచిది?"
"సరే, మన దగ్గర చాలా పెద్ద స్ట్రింగ్ ఉందని అనుకుందాం మరియు దాని చివరకి మనం తరచుగా ఏదైనా జోడించాలి. ఈ సందర్భంలో, అక్షరాలు ( ArrayList<Character>
) యొక్క సమాహారం కూడా స్ట్రింగ్ వస్తువులను నిరంతరం పునఃసృష్టించడం మరియు కలపడం కంటే మరింత ప్రభావవంతంగా ఉంటుంది."
"అందుకే మనకు స్ట్రింగ్ క్లాస్ లేని స్ట్రింగ్లు కావాలి?"
"సరిగ్గా. జావా భాష మార్చగలిగే స్ట్రింగ్ లాంటి రకాన్ని జోడించింది. దానిని StringBuilder
"అంటారు.
ఒక వస్తువును సృష్టించడం
"ఇప్పటికే ఉన్న స్ట్రింగ్ ఆధారంగా ఆబ్జెక్ట్ను సృష్టించడానికి StringBuilder
, మీరు ఇలాంటి స్టేట్మెంట్ను అమలు చేయాలి:
StringBuilder name = new StringBuilder(string);
"ఖాళీగా మార్చగల స్ట్రింగ్ని సృష్టించడానికి, మీరు ఇలాంటి స్టేట్మెంట్ను ఉపయోగించాలి:
StringBuilder name = new StringBuilder();
పద్ధతుల జాబితా
" StringBuilder
తరగతిలో రెండు డజన్ల సహాయక పద్ధతులు ఉన్నాయి. ఇక్కడ చాలా ముఖ్యమైనవి ఉన్నాయి:
పద్ధతి | వివరణ |
---|---|
|
పాస్ చేసిన వస్తువును స్ట్రింగ్గా మారుస్తుంది మరియు దానిని ప్రస్తుత స్ట్రింగ్కు జోడిస్తుంది |
|
పాస్ చేసిన వస్తువును స్ట్రింగ్గా మారుస్తుంది మరియు ప్రస్తుత స్ట్రింగ్ మధ్యలో ఇన్సర్ట్ చేస్తుంది |
|
ప్రారంభం..ముగింపు విరామం ద్వారా పేర్కొన్న స్ట్రింగ్ భాగాన్ని పాస్ చేసిన స్ట్రింగ్తో భర్తీ చేస్తుంది |
|
స్ట్రింగ్ నుండి పేర్కొన్న సూచికతో అక్షరాన్ని తీసివేస్తుంది |
|
స్ట్రింగ్ నుండి పేర్కొన్న విరామంలో అక్షరాలను తొలగిస్తుంది |
|
ప్రస్తుత స్ట్రింగ్లో సబ్స్ట్రింగ్ కోసం శోధిస్తుంది |
|
ప్రస్తుత స్ట్రింగ్లోని సబ్స్ట్రింగ్ కోసం శోధిస్తుంది, చివరి నుండి ప్రారంభమవుతుంది |
|
పాస్ చేసిన సూచికలో స్ట్రింగ్లోని అక్షరాన్ని అందిస్తుంది |
|
పేర్కొన్న విరామం ద్వారా నిర్వచించబడిన సబ్స్ట్రింగ్ను అందిస్తుంది |
|
ప్రస్తుత స్ట్రింగ్ను రివర్స్ చేస్తుంది. |
|
పేర్కొన్న సూచికలోని అక్షరాన్ని పాస్ చేసిన అక్షరానికి మారుస్తుంది |
|
అక్షరాల్లో స్ట్రింగ్ పొడవును అందిస్తుంది |
"ఇప్పుడు నేను ఈ పద్ధతుల్లో ప్రతిదాన్ని మీకు క్లుప్తంగా వివరిస్తాను.
స్ట్రింగ్కు జోడించడం
"మార్పు చేయగల స్ట్రింగ్ ( )కి ఏదైనా జోడించడానికి StringBuilder
, append()
పద్ధతిని ఉపయోగించండి. ఉదాహరణ:
కోడ్ | వివరణ |
---|---|
|
Hi |
ప్రామాణిక స్ట్రింగ్కి మారుస్తోంది
"ఒక వస్తువును స్ట్రింగ్ ఆబ్జెక్ట్గా మార్చడానికి , మీరు దాని పద్ధతిని StringBuilder
కాల్ చేయాలి . ఉదాహరణtoString()
కోడ్ | అవుట్పుట్ |
---|---|
|
Hi123 |
నేను అక్షరాన్ని ఎలా తొలగించగలను?
"మార్పు చేయగల స్ట్రింగ్లోని అక్షరాన్ని తొలగించడానికి, మీరు పద్ధతిని ఉపయోగించాలి deleteCharAt()
. ఉదాహరణ:
కోడ్ | అవుట్పుట్ |
---|---|
|
Helo |
నేను స్ట్రింగ్లోని భాగాన్ని మరొక స్ట్రింగ్తో ఎలా భర్తీ చేయాలి?
"దీనికి ఒక replace(int begin, int end, String str)
పద్ధతి ఉంది. ఉదాహరణ:
కోడ్ | అవుట్పుట్ |
---|---|
|
MeHello!w |
"అనుకూలంగా ఉంది. ధన్యవాదాలు, రిషీ."
"దాని గురించి చెప్పవద్దు. దీని గురించి, మీరు ఒక తీగను వెనుకకు తిప్పగలరా? మీరు దీన్ని ఎలా చేస్తారు?"
"సరే... నేను ఒక క్రియేట్ చేస్తాను StringBuilder
, అందులో స్ట్రింగ్ ఉంచుతాను... తర్వాత కొత్త స్ట్రింగ్ని క్రియేట్ చేస్తాను మరియు చివరి అక్షరం నుండి మొదటి అక్షరానికి లూప్లో క్రియేట్ చేస్తాను... లేదా బిట్వైస్ షిఫ్ట్ కావచ్చు...
"చెడు కాదు. కానీ ఇది వేగంగా ఉంటుంది. దీన్ని చేయడానికి ఒక ప్రత్యేక పద్ధతి ఉంది - reverse();
ఉదాహరణ:
కోడ్ | అవుట్పుట్ |
---|---|
|
olleH |
" StringBuilder
తరగతితో పాటు, జావాలో మరొక స్ట్రింగ్ లాంటి క్లాస్ ఉంది StringBuffer
. ఇది StringBuilder
క్లాస్ యొక్క అనలాగ్, కానీ దాని పద్ధతులు మాడిఫైయర్తో గుర్తించబడ్డాయి synchronized
."
"అంటే ఏమిటి?"
StringBuffer
" బహుళ థ్రెడ్ల నుండి ఆబ్జెక్ట్ను ఏకకాలంలో యాక్సెస్ చేయవచ్చని దీని అర్థం ."
"నాకు ఇంకా థ్రెడ్ల గురించి పెద్దగా పరిచయం లేదు. కానీ 'మల్టిపుల్ థ్రెడ్ల నుండి యాక్సెస్ చేయవచ్చు' అనేది 'మల్టిపుల్ థ్రెడ్ల నుండి యాక్సెస్ చేయలేము' కంటే మెరుగ్గా ఉంది... అలాంటప్పుడు ఎందుకు ఉపయోగించకూడదు? StringBuffer
"
"ఎందుకంటే ఇది చాలా నెమ్మదిగా ఉంటుంది . మీరు జావా మల్టీథ్రెడింగ్StringBuilder
క్వెస్ట్లో మల్టీథ్రెడింగ్ను చురుకుగా అన్వేషించడం ప్రారంభించినప్పుడు మీకు అలాంటి తరగతి అవసరం కావచ్చు .
"నేను దానిని మరచిపోకుండా నా జ్ఞాపకార్థం వ్రాస్తాను. 'భవిష్యత్తు కోసం' అని గుర్తించబడింది.