స్ట్రింగ్ బిల్డర్

"నమస్కారాలు, అమిగో!"

"హలో, రిషీ!"

"ఆసక్తికరమైనదాన్ని నేర్చుకోవడానికి మీకు ఇప్పుడు స్ట్రింగ్‌ల గురించి తగినంతగా తెలుసు. మరింత ప్రత్యేకంగా, స్ట్రింగ్ క్లాస్‌ని పోలి ఉండే కొత్త క్లాస్, కానీ సరిగ్గా అదే కాదు."

"సాధారణ స్ట్రింగ్‌లు ఎలా తగ్గుతాయో మరియు ఇతర స్ట్రింగ్-వంటి తరగతులు ఎందుకు అవసరమో నాకు పూర్తిగా స్పష్టంగా తెలియనప్పటికీ, చమత్కారంగా అనిపిస్తుంది."

"తీగలు జావాలో మార్పులేని వస్తువులు అనే వాస్తవంతో ప్రారంభిద్దాం."

"అది ఎలా? నేను మర్చిపోయాను ... లేదా నేను ప్రారంభించాలని నాకు ఎప్పుడూ తెలియదు ..."

"మారలేని వస్తువులు అవి సృష్టించబడిన తర్వాత వాటి స్థితిని మార్చలేనివి అని నేను మీకు గుర్తు చేస్తాను."

"ఆహ్... జావాలో తీగలు ఎందుకు మారవు?"

"ఇది స్ట్రింగ్ క్లాస్‌ను అత్యంత ఆప్టిమైజ్ చేయడానికి మరియు ప్రతిచోటా ఉపయోగించడానికి అనుమతించడానికి చేయబడింది. ఉదాహరణకు, HashMap సేకరణలో కీలుగా ఉపయోగించడానికి మార్పులేని రకాలు మాత్రమే సిఫార్సు చేయబడ్డాయి .

"అయినప్పటికీ, స్ట్రింగ్ క్లాస్ మార్చగలిగేలా ప్రోగ్రామర్లు మరింత సౌకర్యవంతంగా భావించే సందర్భాలు తరచుగా తలెత్తుతాయి. వారు ఒక పద్ధతిని పిలిచిన ప్రతిసారీ కొత్త సబ్‌స్ట్రింగ్‌ను సృష్టించని తరగతిని కోరుకుంటారు."

"అయితే అది దేనికి మంచిది?"

"సరే, మన దగ్గర చాలా పెద్ద స్ట్రింగ్ ఉందని అనుకుందాం మరియు దాని చివరకి మనం తరచుగా ఏదైనా జోడించాలి. ఈ సందర్భంలో, అక్షరాలు ( ArrayList<Character>) యొక్క సమాహారం కూడా స్ట్రింగ్ వస్తువులను నిరంతరం పునఃసృష్టించడం మరియు కలపడం కంటే మరింత ప్రభావవంతంగా ఉంటుంది."

"అందుకే మనకు స్ట్రింగ్ క్లాస్ లేని స్ట్రింగ్‌లు కావాలి?"

"సరిగ్గా. జావా భాష మార్చగలిగే స్ట్రింగ్ లాంటి రకాన్ని జోడించింది. దానిని StringBuilder"అంటారు.

ఒక వస్తువును సృష్టించడం

"ఇప్పటికే ఉన్న స్ట్రింగ్ ఆధారంగా ఆబ్జెక్ట్‌ను సృష్టించడానికి StringBuilder, మీరు ఇలాంటి స్టేట్‌మెంట్‌ను అమలు చేయాలి:

StringBuilder name = new StringBuilder(string);

"ఖాళీగా మార్చగల స్ట్రింగ్‌ని సృష్టించడానికి, మీరు ఇలాంటి స్టేట్‌మెంట్‌ను ఉపయోగించాలి:

StringBuilder name = new StringBuilder();

పద్ధతుల జాబితా

" StringBuilderతరగతిలో రెండు డజన్ల సహాయక పద్ధతులు ఉన్నాయి. ఇక్కడ చాలా ముఖ్యమైనవి ఉన్నాయి:

StringBuilder append(obj)

StringBuilder insert(int index, obj)

StringBuilder replace(int start, int end, String str)

StringBuilder deleteCharAt(int index)

StringBuilder delete(int start, int end)

int indexOf(String str, int index)

int lastIndexOf(String str, int index)

char charAt(int index)

String substring(int start, int end)

StringBuilder reverse()

void setCharAt(int index, char)

int length()

"ఇప్పుడు నేను ఈ పద్ధతుల్లో ప్రతిదాన్ని మీకు క్లుప్తంగా వివరిస్తాను.

స్ట్రింగ్‌కు జోడించడం

"మార్పు చేయగల స్ట్రింగ్ ( )కి ఏదైనా జోడించడానికి StringBuilder, append()పద్ధతిని ఉపయోగించండి. ఉదాహరణ:

StringBuilder builder = new StringBuilder("Hi");
builder.append("Bye");
builder.append(123);

ప్రామాణిక స్ట్రింగ్‌కి మారుస్తోంది

"ఒక వస్తువును స్ట్రింగ్ ఆబ్జెక్ట్‌గా మార్చడానికి , మీరు దాని పద్ధతిని StringBuilderకాల్ చేయాలి . ఉదాహరణtoString()

StringBuilder builder = new StringBuilder("Hi");
builder.append(123);
String result = builder.toString();
System.out.println(result);

నేను అక్షరాన్ని ఎలా తొలగించగలను?

"మార్పు చేయగల స్ట్రింగ్‌లోని అక్షరాన్ని తొలగించడానికి, మీరు పద్ధతిని ఉపయోగించాలి deleteCharAt(). ఉదాహరణ:

StringBuilder builder = new StringBuilder("Hello");
builder.deleteCharAt(2);
String result = builder.toString();
System.out.println(result);

నేను స్ట్రింగ్‌లోని భాగాన్ని మరొక స్ట్రింగ్‌తో ఎలా భర్తీ చేయాలి?

"దీనికి ఒక replace(int begin, int end, String str)పద్ధతి ఉంది. ఉదాహరణ:

StringBuilder builder = new StringBuilder("Mellow");
builder.replace(2, 5, "Hello!");
String result = builder.toString();
System.out.println(result);

"అనుకూలంగా ఉంది. ధన్యవాదాలు, రిషీ."

"దాని గురించి చెప్పవద్దు. దీని గురించి, మీరు ఒక తీగను వెనుకకు తిప్పగలరా? మీరు దీన్ని ఎలా చేస్తారు?"

"సరే... నేను ఒక క్రియేట్ చేస్తాను StringBuilder, అందులో స్ట్రింగ్ ఉంచుతాను... తర్వాత కొత్త స్ట్రింగ్‌ని క్రియేట్ చేస్తాను మరియు చివరి అక్షరం నుండి మొదటి అక్షరానికి లూప్‌లో క్రియేట్ చేస్తాను... లేదా బిట్‌వైస్ షిఫ్ట్ కావచ్చు...

"చెడు కాదు. కానీ ఇది వేగంగా ఉంటుంది. దీన్ని చేయడానికి ఒక ప్రత్యేక పద్ధతి ఉంది - reverse();ఉదాహరణ:

String str = "Hello";
StringBuilder builder = new StringBuilder(str);
builder.reverse();
String result = builder.toString();
System.out.println(result);

" StringBuilderతరగతితో పాటు, జావాలో మరొక స్ట్రింగ్ లాంటి క్లాస్ ఉంది StringBuffer. ఇది StringBuilderక్లాస్ యొక్క అనలాగ్, కానీ దాని పద్ధతులు మాడిఫైయర్‌తో గుర్తించబడ్డాయి synchronized."

"అంటే ఏమిటి?"

StringBuffer" బహుళ థ్రెడ్‌ల నుండి ఆబ్జెక్ట్‌ను ఏకకాలంలో యాక్సెస్ చేయవచ్చని దీని అర్థం ."

"నాకు ఇంకా థ్రెడ్‌ల గురించి పెద్దగా పరిచయం లేదు. కానీ 'మల్టిపుల్ థ్రెడ్‌ల నుండి యాక్సెస్ చేయవచ్చు' అనేది 'మల్టిపుల్ థ్రెడ్‌ల నుండి యాక్సెస్ చేయలేము' కంటే మెరుగ్గా ఉంది... అలాంటప్పుడు ఎందుకు ఉపయోగించకూడదు? StringBuffer"

"ఎందుకంటే ఇది చాలా నెమ్మదిగా ఉంటుంది . మీరు జావా మల్టీథ్రెడింగ్StringBuilder క్వెస్ట్‌లో మల్టీథ్రెడింగ్‌ను చురుకుగా అన్వేషించడం ప్రారంభించినప్పుడు మీకు అలాంటి తరగతి అవసరం కావచ్చు .

"నేను దానిని మరచిపోకుండా నా జ్ఞాపకార్థం వ్రాస్తాను. 'భవిష్యత్తు కోసం' అని గుర్తించబడింది.