నేను స్ట్రింగ్‌లతో అనుబంధించబడిన అన్ని తరగతులను జాబితా చేస్తాను మరియు అవి మరియు వాటి అన్ని పద్ధతులు ఏమి చేస్తాయో వివరిస్తాను

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

"అయితే, బిలాబో, మీరు ఇప్పటికే హలో చెప్పారు."

"నిజంగానా? సరే, నేను ఇప్పటికీ ప్రతి పాఠాన్ని ఆ పదబంధంతో ప్రారంభించాలనుకుంటున్నాను."

"ఈ రోజు మనం స్ట్రింగ్ క్లాస్‌ని లోతుగా అధ్యయనం చేయబోతున్నాం."

"కానీ, దాని గురించి నాకు ఇప్పటికే ప్రతిదీ తెలుసు. స్ట్రింగ్ క్లాస్ మార్పులేనిదని కూడా నాకు తెలుసు."

"స్ట్రింగ్ క్లాస్‌లో 46 పద్ధతులు ఉన్నాయి. వాటిలో ఎన్ని మీకు తెలుసు?"

"పది కంటే ఎక్కువ కాదు. వాస్తవానికి, దాదాపు 5 గరిష్టంగా ఉంటుంది."

"అయితే వినండి."

"జావా సృష్టికర్తలు ప్రోగ్రామ్‌లలోని చాలా స్ట్రింగ్‌లను సవరించడానికి ఉద్దేశించబడలేదని గమనించారు, కానీ కొన్నిసార్లు అవి ఏమైనప్పటికీ సవరించబడతాయి. మీరు స్ట్రింగ్‌ను సృష్టించినప్పుడు, దానిలో ముఖ్యమైనదాన్ని సేవ్ చేసినప్పుడు, వేరొకరి పద్ధతికి పంపినప్పుడు మరియు అది మార్చబడినప్పుడు చాలా చికాకుగా ఉంటుంది. . ఇది జరగకుండా ఉండటానికి, వారు మార్చగల మరియు మార్పులేని తీగలను సృష్టించాలని నిర్ణయించుకున్నారు."

"స్ట్రింగ్ క్లాస్ అనేది మార్చలేని స్ట్రింగ్‌ల కోసం, మరియు స్ట్రింగ్‌బిల్డర్ క్లాస్ మార్చగలిగే వాటి కోసం. ఈ క్లాస్‌ల వస్తువులు సులభంగా ఇతర రకానికి మార్చబడతాయి. చాలా సందర్భాలలో, జావా డెవలపర్‌లకు స్ట్రింగ్ అవసరం, ఇది జావా సృష్టికర్తలు సరైనదేనని రుజువు చేస్తుంది."

"కాబట్టి నాకు స్ట్రింగ్ అవసరమైతే, నేను స్ట్రింగ్ క్లాస్‌ని ఉపయోగిస్తాను. మరియు నాకు మ్యూటబుల్ స్ట్రింగ్ అవసరమైతే, నేను స్ట్రింగ్‌బిల్డర్ క్లాస్‌ని ఉపయోగిస్తానా ?"

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

"మరియు ఈ ఉదాహరణ గురించి ఏమిటి? ఇక్కడ స్ట్రింగ్ మారలేదా?"

String s = "cat";
s = s + "-" + s;

"లేదు. ఇక్కడ రెండు స్ట్రింగ్ వస్తువులు ఉన్నాయి: «పిల్లి» మరియు «పిల్లి-పిల్లి». రెండవది మొదటిదాన్ని ఉపయోగించి సృష్టించబడింది, కానీ మొదటి వస్తువు మారదు. వాస్తవానికి, ఇక్కడ విషయాలు చాలా ఆసక్తికరంగా ఉన్నాయి. ఇక్కడ కోడ్ ఉంది కంపైలర్ మీ ఉదాహరణను కంపైల్ చేసినప్పుడు ఉత్పత్తి చేస్తుంది:"

String s = "cat";
StrinsBuilder s2 = new StringBuilder(s);
s2.append("-");
s2.append(s);
s = s2.toString();

"కాబట్టి, StringBuilder దాదాపు ఎల్లప్పుడూ కొత్త స్ట్రింగ్‌లను సృష్టించడానికి ఉపయోగించబడుతుంది, కానీ కొన్నిసార్లు కంపైలర్ మీ కోసం అన్ని పనిని చేస్తుంది. కానీ మీ సంస్కరణ సరళమైనది, మీరు అనుకోలేదా?"

"అవును, జావాలో ఇంత అధునాతన కంపైలర్ ఉండటం చాలా అద్భుతంగా ఉంది."

"సరే, ఇప్పుడు స్ట్రింగ్ క్లాస్ పద్ధతుల ద్వారా నడుద్దాం:"

1) నేను స్ట్రింగ్ యొక్క పొడవును ఎలా కనుగొనగలను?

" పొడవు పద్ధతి స్ట్రింగ్ యొక్క పొడవును (దానిలోని అక్షరాల సంఖ్య) అందిస్తుంది."

int length();

String s = "Good news, everyone!";
int n = s.length();

int n = "Good news, everyone!".length();

2) నేను స్ట్రింగ్ నుండి పాత్రను ఎలా పొందగలను?

" charAt పద్ధతి దాని సూచిక ద్వారా స్ట్రింగ్ నుండి అక్షరాన్ని అందిస్తుంది. అక్షర సూచికలు 0 వద్ద ప్రారంభమవుతాయి.

char charAt(int index)

String s = "Good news, everyone!";
char n = s.charAt(5);

char n = "Good news, everyone!".charAt(5);

3) నేను స్ట్రింగ్ నుండి అక్షరాలను ఎలా పొందగలను?

నేను స్ట్రింగ్ నుండి అక్షరాలను ఎలా పొందగలను?

char[]toCharArray ()

String s = "Good news, everyone!";
for(char c: s.toCharArray())
{
System.out.println(c);
}

4) నేను తీగలను ఎలా పోల్చగలను?

"ఈక్వల్స్ మెథడ్ స్ట్రింగ్‌లు సరిపోలితే తనిఖీ చేస్తుంది మరియు కేస్ విస్మరించబడినప్పుడు స్ట్రింగ్స్ మ్యాచ్ అవుతుందో లేదో చూడటానికి ఈక్వెల్స్ ఇగ్నోర్‌కేస్ పద్ధతి తనిఖీ చేస్తుంది.

boolean equals(Object o)

String s = "cat";
boolean test1 = s.equals("cat");//true
boolean test2 = s.equals("Cat");//false
boolean test3 = s.equals("c"+"a"+"t");//true

boolean equalsIgnoreCase(String str)

String s = "cat";
boolean test1 = s.equalsIgnoreCase("cat");//true
boolean test2 = s.equalsIgnoreCase("Cat");//true
boolean test3 = s.equalsIgnoreCase("cAT");//true

5) నేను అన్ని అక్షరాలను స్ట్రింగ్ పెద్ద అక్షరం లేదా చిన్న అక్షరంలో ఎలా తయారు చేయాలి?

" toUpperCase పద్ధతి అన్ని పెద్ద అక్షరాలతో స్ట్రింగ్ కాపీని అందిస్తుంది."

" toLowerCase పద్ధతి అన్ని చిన్న అక్షరాలతో స్ట్రింగ్ కాపీని అందిస్తుంది."

String toUpperCase()

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

s == "GOOD NEWS, EVERYONE!";

String toLowerCase()

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

s == "good news, everyone!";

6) స్ట్రింగ్ ప్రారంభంలో మరియు చివరిలో ఖాళీలను ఎలా తొలగించాలి?

"ట్రిమ్ పద్ధతి ప్రారంభంలో మరియు ముగింపులో వైట్‌స్పేస్ అక్షరాలు లేకుండా స్ట్రింగ్ కాపీని అందిస్తుంది."

String trim()

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

s == "Good news, everyone!";