జావాలో స్ట్రింగ్స్‌తో పని చేయడానికి అనుకూలమైన తరగతులు

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

"హాయ్, అమిగో! ఈ రోజు మనం స్ట్రింగ్‌లతో పని చేసే మరికొన్ని సాధారణ దృశ్యాలను విశ్లేషిస్తాము. ఉదాహరణకు, స్ట్రింగ్‌ను అనేక భాగాలుగా ఎలా విభజించాలో మీకు తెలుసా?"

"నేను మీకు వెంటనే చెప్పను, ఎల్లీ, కానీ మీరు నాకు చెప్పబోతున్నారు, అవునా?"

split()పద్ధతి

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

ఉదాహరణ:

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

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

సాధారణ, కానీ కొన్నిసార్లు ఈ విధానం అధికంగా ఉంటుంది. చాలా డీలిమిటర్‌లు ఉంటే (ఉదాహరణకు, ఖాళీలు, కొత్త లైన్ అక్షరాలు, ట్యాబ్‌లు, పీరియడ్‌లు), అప్పుడు మీరు సంక్లిష్టమైన సాధారణ వ్యక్తీకరణను నిర్మించాలి."

"అలాగే, ఖచ్చితంగా. మరియు చదవడం కష్టంగా ఉంటే, మార్పులు చేయడం కష్టం.

StringTokenizerతరగతి

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

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

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

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

String nextToken()

boolean hasMoreTokens()

"ఈ తరగతి నాకు స్కానర్ క్లాస్‌ని గుర్తు చేస్తుంది, ఇందులో కూడా nextLine()పద్ధతులు ఉన్నాయి hashNextLine().

StringTokenizer"ఇది మీరు చేసిన మంచి పరిశీలన. మీరు ఈ ఆదేశంతో ఒక వస్తువును సృష్టించవచ్చు :

StringTokenizer name = new StringTokenizer(string, delimiters);

స్ట్రింగ్ అంటే భాగాలుగా విభజించాల్సిన స్ట్రింగ్. మరియు డీలిమిటర్లు ఒక స్ట్రింగ్ మరియు దానిలోని ప్రతి అక్షరం డీలిమిటర్‌గా పరిగణించబడుతుంది. ఉదాహరణ:

String str = "Good news everyone!";

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

Good 
ws 
v
ryo
!

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

String.format()పద్ధతి మరియు StringFormatterతరగతి

"స్ట్రింగ్ క్లాస్ యొక్క మరొక ఆసక్తికరమైన పద్ధతి format().

"మీరు డేటాను నిల్వ చేసే వివిధ వేరియబుల్‌లను కలిగి ఉన్నారని అనుకుందాం. మీరు వాటిని స్క్రీన్‌పై ఒక లైన్‌లో ఎలా ప్రదర్శిస్తారు? ఉదాహరణకు, మాకు కొంత డేటా (ఎడమ కాలమ్) మరియు కావలసిన అవుట్‌పుట్ (కుడి నిలువు వరుస):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

అటువంటి ప్రోగ్రామ్ కోసం కోడ్ ఇలా కనిపిస్తుంది:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

"కోడ్ చాలా చదవదగినది కాదని మీరు నాతో అంగీకరిస్తారు. మరియు వేరియబుల్ పేర్లు పొడవుగా ఉంటే, కోడ్ మరింత కష్టతరం అవుతుంది:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

"అవును, చదవడం చాలా కష్టం!"

"చింతించకండి. ఇది వాస్తవ-ప్రపంచ ప్రోగ్రామ్‌లలో సాధారణ పరిస్థితి, కాబట్టి ఈ కోడ్‌ను మరింత సరళంగా మరియు మరింత సంక్షిప్తంగా వ్రాయడానికి ఒక మార్గం గురించి నేను మీకు చెప్పాలనుకుంటున్నాను.

String.format

" Stringతరగతి స్టాటిక్ format()పద్ధతిని కలిగి ఉంది: ఇది డేటాతో స్ట్రింగ్‌ను అసెంబ్లింగ్ చేయడానికి ఒక నమూనాను పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది. కమాండ్ యొక్క సాధారణ రూపం క్రింది విధంగా ఉంటుంది:

String name = String.format(pattern, parameters);

ఉదాహరణ:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

" పద్ధతి యొక్క మొదటి పరామితి అనేది మీరు డేటాను చొప్పించాల్సిన ప్రదేశాలలో format()ఫార్మాట్ స్పెసిఫైయర్‌లు (ఉదాహరణకు %dమరియు ) అని పిలువబడే ప్రత్యేక అక్షరాలతో పాటు కావలసిన అన్ని టెక్స్ట్‌లను కలిగి ఉండే ఫార్మాట్ స్ట్రింగ్.%s

" format()పద్ధతి వీటిని %sమరియు %dఫార్మాట్ స్పెసిఫైయర్‌లను పారామీటర్ జాబితాలోని ఫార్మాట్ స్ట్రింగ్‌ను అనుసరించే పారామీటర్‌లతో భర్తీ చేస్తుంది. మనం స్ట్రింగ్‌ను చొప్పించాలనుకుంటే, అప్పుడు వ్రాస్తాము. %sమనం ఒక సంఖ్యను చొప్పించాలనుకుంటే, ఫార్మాట్ స్పెసిఫైయర్ %d. ఉదాహరణ:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

"ఫార్మాట్ స్ట్రింగ్ లోపల ఉపయోగించగల ఫార్మాట్ స్పెసిఫైయర్‌ల యొక్క చిన్న జాబితా ఇక్కడ ఉంది:

%s

%d

%f

%b

%c

%t

%%

"ఈ స్పెసిఫైయర్‌లు డేటా రకాన్ని సూచిస్తాయి, కానీ డేటా క్రమాన్ని సూచించే స్పెసిఫైయర్‌లు కూడా ఉన్నాయి. దాని సంఖ్య ద్వారా ఆర్గ్యుమెంట్ పొందడానికి (నంబరింగ్ ఒకదాని నుండి ప్రారంభమవుతుంది), మీరు " % 1$ d "కి బదులుగా వ్రాయాలి. %d ". ఉదాహరణ:

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$d3వ వాదనను పొందుతారు, %2$dరెండవ వాదనను పొందుతారు మరియు %dమొదటి వాదనను పొందుతారు. %sమరియు ఫార్మాట్ స్పెసిఫైయర్‌లు లేదా %dవంటి స్పెసిఫైయర్‌లతో సంబంధం లేకుండా ఆర్గ్యుమెంట్‌లను సూచిస్తాయి%3$d%2$s

స్ట్రింగ్ పూల్

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

"మొదట, కోడ్‌లో పేర్కొన్న స్ట్రింగ్‌లు తప్పనిసరిగా ఎక్కడో నిల్వ చేయబడాలి, సరియైనదా? కోడ్ ఆదేశాలను కలిగి ఉంటుంది, అయితే డేటా (ముఖ్యంగా, పెద్ద స్ట్రింగ్‌లు) మెమరీలో కోడ్ నుండి విడిగా నిల్వ చేయబడాలి. స్ట్రింగ్ ఆబ్జెక్ట్‌లకు సంబంధించిన సూచనలు మాత్రమే కోడ్‌లో కనిపిస్తాయి.

StringPool"రెండవది, అన్ని ఒకేలాంటి స్ట్రింగ్ లిటరల్స్ ఒక్కసారి మాత్రమే మెమరీలో నిల్వ చేయబడాలి. మరియు అది ఎలా పని చేస్తుంది. మీ క్లాస్ కోడ్ జావా మెషీన్ ద్వారా లోడ్ చేయబడినప్పుడు, అన్ని స్ట్రింగ్ లిటరల్స్ ఇప్పటికే అక్కడ లేకుంటే దానికి జోడించబడతాయి. అవి ఉంటే ఇప్పటికే ఉంది, అప్పుడు మేము కేవలం నుండి స్ట్రింగ్ సూచనను ఉపయోగిస్తాము StringPool.

తదనుగుణంగా, మీరు మీ కోడ్‌లోని అనేక స్ట్రింగ్ వేరియబుల్స్‌కు ఒకే లిటరల్‌ను కేటాయించినట్లయితే, ఈ వేరియబుల్స్ ఒకే సూచనను కలిగి ఉంటాయి. అక్షరార్థం ఒక్కసారి మాత్రమే జోడించబడుతుంది StringPool. అన్ని ఇతర సందర్భాల్లో, కోడ్‌లో ఇప్పటికే లోడ్ చేయబడిన స్ట్రింగ్‌కు సూచన వస్తుంది StringPool.

ఇది సుమారుగా ఎలా పని చేస్తుందో ఇక్కడ ఉంది:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

"అందుకే aమరియు bవేరియబుల్స్ ఒకే సూచనలను నిల్వ చేస్తాయి."

"నేను అన్నింటినీ సరిగ్గా అర్థం చేసుకున్నానని ఆశిస్తున్నాను.

intern()పద్ధతి.

"మరియు ఉత్తమమైన విషయం ఏమిటంటే, మీరు ప్రోగ్రామాటిక్‌గా ఏదైనా స్ట్రింగ్‌ని జోడించవచ్చు . దీన్ని చేయడానికి, మీరు వేరియబుల్ పద్ధతిని StringPoolకాల్ చేయాలి .Stringintern()

" intern()పద్ధతి స్ట్రింగ్‌ను StringPoolఇప్పటికే అక్కడ లేకుంటే దానికి జోడిస్తుంది మరియు స్ట్రింగ్‌కు సూచనను అందిస్తుంది StringPool.

StringPool"మరియు పద్ధతిని ఉపయోగించి రెండు ఒకేలా తీగలను జోడించినట్లయితే ఏమి జరుగుతుంది intern()?"

"పద్ధతి అదే సూచనలను అందిస్తుంది. ఇది సూచన ద్వారా స్ట్రింగ్‌లను సరిపోల్చడానికి ఉపయోగించవచ్చు. ఉదాహరణ:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

మీరు ఈ పద్ధతిని తరచుగా ఉపయోగించే అవకాశం లేదు. ఉద్యోగ ఇంటర్వ్యూలలో ప్రజలు దాని గురించి అడగడానికి ఇష్టపడతారు.

"కాబట్టి, తెలియకుండా ఉండటం కంటే దాని గురించి తెలుసుకోవడం మంచిది. ధన్యవాదాలు, ఎల్లీ!"