StringTokenizer, String.replace, మరియు String.split

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

"నాకు తెలిసినంత వరకు రిషి మీకు రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ గురించి ముందే చెప్పాడు."

"అవును, ఇది చాలా ఆసక్తికరంగా ఉంది."

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

"సరళమైన ప్రశ్నతో ప్రారంభిద్దాం:"

1) సాధారణ వ్యక్తీకరణ ద్వారా పేర్కొన్న నమూనాతో స్ట్రింగ్ సరిపోలుతుందో లేదో నేను ఎలా తనిఖీ చేయాలి?

"దీనికి మ్యాచ్‌ల పద్ధతి ఉంది. మీరు సాధారణ వ్యక్తీకరణను కలిగి ఉన్న స్ట్రింగ్‌ను పాస్ చేస్తారు మరియు పద్ధతి ఒప్పు లేదా తప్పు అని చూపుతుంది."

boolean matches(String regex)

String s = "Good news, everyone!";
Boolean test = s.matches("news\\.*");

false (the String doesn't start with "news")

2) నేను అన్ని మ్యాచింగ్ సబ్‌స్ట్రింగ్‌లను వేర్వేరు స్ట్రింగ్‌లతో ఎలా భర్తీ చేయాలి?

"దీనికి రెండు పద్ధతులు ఉన్నాయి."

" అన్ని రీప్లేస్ మెథడ్ సబ్‌స్ట్రింగ్ యొక్క అన్ని సంఘటనలను మరొక స్ట్రింగ్‌తో భర్తీ చేస్తుంది."

" రిప్లేస్ ఫస్ట్ మెథడ్ పాస్ చేసిన సబ్‌స్ట్రింగ్ యొక్క మొదటి సంఘటనను పేర్కొన్న స్ట్రింగ్‌తో భర్తీ చేస్తుంది."

String replaceAll(String regex, String replacement)

String s = "Good news, everyone!";
String s2 = s.replaceAll ("e\\.","EX");

s2 == "Good nEXs EXEXyonEX";

String replaceFirst(String regex, String replacement)

String s = "Good news, everyone!";
String s2 = s.replaceFirst("e\\.","EX");

s2 == "Good nEXs, everyone!";

3) నేను స్ట్రింగ్‌ను భాగాలుగా ఎలా విభజించగలను?

"దీని కోసం, మేము విభజన పద్ధతిని కలిగి ఉన్నాము, ఇది డీలిమిటింగ్ మాస్క్‌ను తీసుకుంటుంది:"

String[] split(String regex)

String s = "Good news everyone!";
String[] ss = s.split("ne");
System.out.println(Arrays.toString(ss));

[Good , ws everyo, !]
"Good ", "ws everyo", "!";

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

"ఈ తరగతి సాధారణ వ్యక్తీకరణలను ఉపయోగించదు. బదులుగా, మీరు డీలిమిటర్‌ల సమితిని కలిగి ఉన్న స్ట్రింగ్‌లో ఉత్తీర్ణత సాధిస్తారు. ఈ విధానం యొక్క ప్రయోజనం ఏమిటంటే ఇది మొత్తం స్ట్రింగ్‌ను ఒకేసారి ముక్కలుగా చేయదు, బదులుగా ఇది నెమ్మదిగా కదులుతుంది ప్రారంభం నుండి చివరి వరకు."

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

తదుపరి టోకెన్ పద్ధతి తదుపరి టోకెన్‌ను (సబ్‌స్ట్రింగ్) అందిస్తుంది.

ఇంకా తిరిగి ఇవ్వని సబ్‌స్ట్రింగ్‌లు ఉన్నట్లయితే hasMoreTokens() పద్ధతి నిజమైనదిగా చూపబడుతుంది.

boolean hasMoreTokens()

String nextToken()

String s = "Good news, everyone!";

StringTokenizer tokenizer =
new StringTokenizer(s,"ne");
while (tokenizer.hasMoreTokens())
{
String token = tokenizer.nextToken();
System.out.println(token);
}

Good
ws
v
ryo
!

"రెండవ స్ట్రింగ్‌లోని ఏదైనా అక్షరం StringTokenizer కన్స్ట్రక్టర్‌కు పంపబడితే అది డీలిమిటర్‌గా పరిగణించబడుతుందని గమనించండి."

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

"అద్భుతం, అప్పుడు మీరు టాపిక్‌పై పట్టు సాధించారని మేము అనుకుంటాము."