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

1. StringTokenizerతరగతి

మరియు ఇప్పుడు స్ట్రింగ్స్‌తో పని చేసే మరికొన్ని సాధారణ దృశ్యాలు. మీరు స్ట్రింగ్‌ను అనేక భాగాలుగా ఎలా విభజిస్తారు? దీన్ని చేయడానికి అనేక మార్గాలు ఉన్నాయి.

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()పద్ధతులు ఉన్నాయి hasNextLine().

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

StringTokenizer name = new StringTokenizer(string, delimiters);

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కన్స్ట్రక్టర్‌కు రెండవ స్ట్రింగ్‌గా పంపబడితే అది సెపరేటర్‌గా పరిగణించబడుతుందని గమనించండి.

2. 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.}");

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

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

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

చాలా చదవగలిగేది కాదు, అవునా?

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

String.format

స్ట్రింగ్ క్లాస్ స్టాటిక్ 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

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

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

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

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

తదనుగుణంగా, మీరు మీ కోడ్‌లోని అనేక వేరియబుల్స్‌కు ఒకే అక్షరార్థాన్ని కేటాయించినట్లయితే String, ఈ వేరియబుల్స్ ఒకే సూచనను కలిగి ఉంటాయి. అక్షరార్థం ఒక్కసారి మాత్రమే జోడించబడుతుంది 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. Stringదీన్ని చేయడానికి, మీరు వేరియబుల్ పద్ధతిని కాల్ చేయాలి intern().

ఈ 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

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