Home-theater-designers
మీరు జావా నేర్చుకోవడం ప్రారంభించిన తర్వాత, స్ట్రింగ్ క్లాస్ మీ దృష్టిని ఆకర్షిస్తుంది, దాని ప్రత్యేక లక్షణాలకు ధన్యవాదాలు.
మీరు ఇతర భాషల కంటే జావాలో స్ట్రింగ్‌లను సులభంగా సృష్టించవచ్చు మరియు మార్చవచ్చు. ఎందుకంటే స్ట్రింగ్ క్లాస్ వివిధ ఫీచర్లను అందిస్తుంది.
ఈ లక్షణాల ఆధారంగా, మీ ప్రాధాన్యతలు మరియు అవసరాలను బట్టి తీగలను రూపొందించడానికి మరియు సవరించడానికి అనేక పద్ధతులు ఉన్నాయి. అదేవిధంగా, మీ అప్లికేషన్ మరియు స్ట్రింగ్‌లను ఎక్కడ ఉపయోగించాలి అనే దానిపై చాలా ఆధారపడి ఉంటుంది.
జావా తీగలు ఎలా విభిన్నంగా ఉన్నాయి?
మీరు గతంలో C లాంగ్వేజ్‌తో పని చేసినట్లయితే, C లోని స్ట్రింగ్స్ ఒక శ్రేణి అని మీకు తెలుసు అక్షరాలు (అక్షరాలు). మరోవైపు, జావా తీగలు మార్పులేనివి మరియు యూనికోడ్ అక్షరాలను కలిగి ఉంటాయి.
jpeg రిజల్యూషన్‌ను ఎలా తగ్గించాలి
జావాలో స్ట్రింగ్‌లను ప్రత్యేకంగా చేసే ముఖ్య లక్షణాలలో ఒకటి సమ్మేళనం. రెండు లేదా అంతకంటే ఎక్కువ స్ట్రింగ్‌లలో చేరడానికి అదనంగా ఆపరేటర్ + ఉపయోగించండి. ఇది మీరు ఇతర జావా వస్తువులతో చేయలేనిది పాయింట్ లేదా వృత్తం .
అలాగే, ముందు చెప్పినట్లుగా, జావా స్ట్రింగ్స్ మార్చలేనివి, అనగా మీరు వాటిని సవరించలేరు. ఉదాహరణకు, వంటి పద్ధతులు పెద్ద కేసు () మరియు దిగువ కేసు () ఇప్పటికే ఉన్న స్ట్రింగ్ కంటెంట్‌లకు మార్పులు చేయడానికి బదులుగా పూర్తిగా కొత్త స్ట్రింగ్‌ని రూపొందించండి. ఇప్పుడు మీ కోడ్ కొత్తగా జనరేట్ చేసిన స్ట్రింగ్‌ని అందిస్తుంది.
సంబంధిత: ఈ విధులతో PHP లో టెక్స్ట్‌ని ఎలా మార్చాలి
సి వంటి భాషలలో తీగలను ముగించడానికి శూన్య అక్షరాలను ఉపయోగించినప్పుడు తీగలు విభిన్నంగా ఉండే మరొక ప్రాంతం, జావాలో, స్ట్రింగ్‌లు అక్షర శ్రేణుల ద్వారా మద్దతిచ్చే వస్తువులు. అక్షర శ్రేణులు వాటిని సూచించే విధంగా మీ స్ట్రింగ్ యొక్క కంటెంట్‌లను చదవడానికి మీరు చూస్తున్నట్లయితే, దాన్ని ఉపయోగించి toCharAraray () పద్ధతి పని చేస్తుంది.
జావాలో తీగలను సరిపోల్చడం ఇతర ప్రోగ్రామింగ్ భాషల కంటే కూడా సౌకర్యవంతంగా ఉంటుంది. స్ట్రింగ్‌లను పోల్చడం కోసం సుదీర్ఘమైన కోడ్‌ని వ్రాసే బదులు, మీరు దీనిని ఉపయోగించవచ్చు సమానం () ఏదైనా ప్రోగ్రామ్‌లో ఉపయోగించే రెండు లేదా అంతకంటే ఎక్కువ స్ట్రింగ్‌లను పోల్చడానికి పద్ధతి. ఇది ప్రధానంగా ఎందుకంటే, జావాలో, ది సమానం స్ట్రింగ్ క్లాస్ ద్వారా పద్ధతి భర్తీ చేయబడుతుంది, ఇది స్ట్రింగ్ పోలికను కేక్ ముక్కగా చేస్తుంది.
ఇదే విధమైన గమనికలో, జావాలోని సబ్‌స్ట్రింగ్‌లలో శోధించడం ఇబ్బంది లేకుండా ఉంటుంది. సాధారణ వ్యక్తీకరణలను ఉపయోగిస్తున్నప్పుడు లేదా వంటి పద్ధతులు lastIndexOf () మరియు indexOf (), మ్యాచ్ గుర్తించిన తర్వాత మీరు స్ట్రింగ్స్ మరియు రిటర్న్ వాల్యూస్ విభాగాలను శోధించవచ్చు. వివిధ స్ట్రింగ్‌లను ట్రిమ్ చేయడానికి మరియు విభజించడానికి మీరు రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను కూడా ఉపయోగించవచ్చు మరియు ఏదైనా ప్రోగ్రామ్‌లో విస్తృతమైన ఉపయోగాల కోసం వాటిని వ్యక్తిగతంగా ఉపయోగించవచ్చు.
మెమరీలో స్ట్రింగ్స్ ఎలా నిల్వ చేయబడతాయి?
జావాలో స్ట్రింగ్‌లు విభిన్నంగా మరియు ప్రయోజనకరంగా ఉండేవి ఏమిటో ఇప్పుడు మీకు తెలుసు, స్ట్రింగ్ క్లాస్‌ని అన్వేషించండి. జావాలో మెమరీ నిర్వహణ గురించి మీకు ఒకటి లేదా రెండు విషయాలు తెలిస్తే, మీరు తప్పనిసరిగా దాని రెండు కీలక సంస్థలతో వ్యవహరించాలి: కుప్ప మరియు స్టాక్.
జావా ప్రోగ్రామ్ ద్వారా పిలువబడిన తర్వాత ప్రక్రియలు మరియు కార్యకలాపాలను అమలు చేయడానికి స్టాక్ ఉపయోగించబడుతుంది, అయితే కుప్ప కంటెంట్‌ను నిల్వ చేస్తుంది - కోడ్‌ను సమర్థవంతంగా అమలు చేయడానికి మరియు అమలు చేయడానికి అవసరం. కాబట్టి, స్ట్రింగ్స్ విషయంలో మెమరీ నిర్వహణ ఎలా సంబంధితంగా ఉంటుంది?
ఎందుకంటే జావాలోని స్ట్రింగ్ క్లాస్ మరియు స్ట్రింగ్ లిటరల్స్ విభిన్న చికిత్సను పొందుతాయి. స్ట్రింగ్ కాన్స్టాంట్ పూల్ అని పిలవబడే స్ట్రింగ్ లిటరల్స్ కుప్ప మెమరీలో ప్రత్యేకమైన స్టోరేజ్ స్పేస్ కేటాయించబడిందని ఇది సూచిస్తుంది. అందువల్ల, మీరు జావాలో స్ట్రింగ్ వస్తువులను సృష్టించడానికి స్ట్రింగ్ లిటరల్స్ ఉపయోగించినప్పుడల్లా, స్ట్రింగ్ కాన్స్టాంట్ పూల్ వాటిని నిల్వ చేస్తుంది.
దీనికి విరుద్ధంగా, మీరు ఉపయోగించినప్పుడు కొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌లను సృష్టించడానికి కీవర్డ్, జావా వాటిని ఏ ఇతర వస్తువులాగే పరిగణిస్తుంది మరియు వాటిని నిల్వ కోసం కుప్పకు పంపుతుంది.
స్ట్రింగ్ లిటరల్స్ ఉదాహరణ
ఇప్పుడు మీకు స్ట్రింగ్ వస్తువుల గురించి తగినంతగా తెలుసు, స్ట్రింగ్ లిటరల్స్ యొక్క ఉదాహరణ ద్వారా వెళ్దాం:
public class muostrings {
public static void main(String args[])
{
String himuo = 'Hello World from MUO';
System. out .println (himuo);
}
}
ఇక్కడ, స్ట్రింగ్ లిటరల్ MUO నుండి హలో వరల్డ్ విషయాలతో స్ట్రింగ్ వస్తువును సృష్టించింది. జావా ఈ వస్తువును స్ట్రింగ్ కాన్స్టాంట్ పూల్‌కు పంపుతుంది.
కొత్త కీవర్డ్‌ని ఉపయోగించడం
మీరు కూడా ఉపయోగించవచ్చు కొత్త స్ట్రింగ్ వస్తువులను రూపొందించడానికి కీవర్డ్.
MUO నుండి హలో వరల్డ్ విషయాలతో స్ట్రింగ్ హిమూవో యొక్క స్ట్రింగ్ వస్తువు స్ట్రింగ్ అక్షరాలా రూపొందించబడింది మరియు స్ట్రింగ్ కాన్స్టాంట్ పూల్‌కు పంపబడుతుంది. అదేవిధంగా, కొత్త కీవర్డ్‌ని ఉపయోగించి స్ట్రింగ్ ఆబ్జెక్ట్‌లను కూడా సృష్టించవచ్చు:
public class muostringsobj {
public static void main(String args[]) {
char [] strArr = { 'M', 'O', 'U'};
String jStr = new String(strArr);
System. out .println( jStr );
}
}
పై ఉదాహరణ ఉపయోగిస్తుంది కొత్త స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించడానికి కీవర్డ్. గతంలో వివరించినట్లుగా, అవి కుప్పకు పంపబడతాయి, అక్కడ అవి ఇతర వేరియబుల్స్ మరియు ప్రోగ్రామ్ ద్వారా అమలు చేయడానికి వేచి ఉన్న వస్తువులతో నిల్వ చేయబడతాయి.
ఇప్పుడు, మీరు స్ట్రింగ్ కాన్స్టాంట్ పూల్ గురించి ఆసక్తిగా ఉండాలి మరియు సరిగ్గా. ఇది స్ట్రింగ్ ఆబ్జెక్ట్ విషయాల ఆధారంగా వస్తువులకు పూల్ స్థలాన్ని కేటాయిస్తుంది. స్ట్రింగ్ కాన్స్టాంట్ పూల్ ఆబ్జెక్ట్‌లను అందుకున్న తర్వాత, రెండు వస్తువులు ఒకే కంటెంట్‌ను కలిగి ఉన్నాయో లేదో తనిఖీ చేయడానికి వాటిని తనిఖీ చేస్తుంది.
రెండు స్ట్రింగ్ ఆబ్జెక్ట్‌లు ఒకే విషయాలను నిల్వ చేయగలవా?
కొత్త వస్తువును సృష్టించడానికి స్ట్రింగ్ అక్షరాలను ఉపయోగించినప్పుడు, జావా వర్చువల్ మెషిన్ (JVM) ఆబ్జెక్ట్ విషయాలను సమీక్షించి, అది ఇప్పటికే పూల్‌లో ఉందో లేదో అంచనా వేస్తుంది. ఒక వస్తువు ఇప్పటికే పూల్‌లో ఉన్న కంటెంట్‌ను కలిగి ఉన్నప్పుడు, కొత్త వస్తువును సృష్టించకుండానే ఆ వస్తువు యొక్క సూచన తిరిగి ఇవ్వబడుతుంది. మీరు తప్పనిసరిగా కొత్త వస్తువును సృష్టించినట్లయితే, కంటెంట్ విభిన్నంగా మరియు ప్రత్యేకంగా ఉందని మీరు నిర్ధారించుకోవాలి.
అయితే, మీరు దీనిని ఉపయోగిస్తే కొత్త కొత్త స్ట్రింగ్‌ని సృష్టించడానికి కీవర్డ్, అది విభిన్నంగా ప్రాసెస్ చేయబడుతుంది. మీరు ఉపయోగించినప్పుడు కొత్త క్రొత్త స్ట్రింగ్‌ను సృష్టించడానికి కీవర్డ్, ఇది ప్రస్తుత స్ట్రింగ్‌లో ఉన్నటువంటి కంటెంట్‌లను కలిగి ఉందో లేదో అనే దానితో సంబంధం లేకుండా రూపొందించబడుతుంది.
కుప్ప మెమరీలో నిల్వ చేయబడిన రెండు స్ట్రింగ్స్ వస్తువులు ఒకే విషయాలను కలిగి ఉండటానికి అనుమతించబడతాయని ఇది సూచిస్తుంది; స్ట్రింగ్ కాన్స్టాంట్ పూల్‌లో నిల్వ చేసిన స్ట్రింగ్ వస్తువుల నుండి ఇది భిన్నంగా ఉంటుంది. మీరు దీనిని == ఆపరేటర్‌తో కూడా నిరూపించవచ్చు; ఒకే భౌతిక చిరునామా కలిగిన రెండు వస్తువులను పోల్చి చూస్తే అది నిజమవుతుంది.
public class comparingStrngs {
public static void main(String[] args)
{
String firstLiteral = 'muo1';
String secondLiteral = 'muo1';
System. out .println(firstLiteral == secondLiteral);
String firstKeyword = new String('muo2');
String secondKeyword = new String('muo2');
System. out .println(firstKeyword == secondKeyword);
}
}
ఇప్పుడు మీరు జావాలోని స్ట్రింగ్‌లను సులభంగా అర్థం చేసుకోవచ్చు
ఈ ఆర్టికల్లో, జావాలోని స్ట్రింగ్స్ ఎలా విభిన్నంగా ఉంటాయో, జావాలో స్ట్రింగ్‌లను ఉపయోగించే మార్గాలు, జావాలోని స్ట్రింగ్‌ల మెమరీ మేనేజ్‌మెంట్ మరియు స్ట్రింగ్స్ ఎలా పనిచేస్తాయనే ఇతర ముఖ్యమైన వివరాలను మీరు నేర్చుకున్నారు. మీ అవగాహనను పరీక్షించడానికి, రెండు తీగలను కలపడానికి జావా ప్రోగ్రామ్‌ను ఎందుకు రాయకూడదు?
షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ పైథాన్ నేర్చుకోవడం? తీగలను ఎలా మార్చాలో ఇక్కడ ఉందిపైథాన్లో స్ట్రింగ్‌లను ఉపయోగించడం మరియు మార్చడం కష్టంగా అనిపించవచ్చు, కానీ ఇది మోసపూరితంగా సూటిగా ఉంటుంది.
తదుపరి చదవండి సంబంధిత అంశాలు- ప్రోగ్రామింగ్
- జావా
ఉస్మాన్ డిజిటల్ ప్లాట్‌ఫామ్‌లలో సేంద్రీయ వృద్ధితో అనేక వ్యాపారాలకు సహాయపడిన కంటెంట్ మార్కెటర్. అతను ప్రోగ్రామింగ్ మరియు రైటింగ్ రెండింటినీ ఇష్టపడతాడు, అంటే టెక్నికల్ రైటింగ్ అతను చాలా ఆనందిస్తాడు. పని చేయనప్పుడు, ఉస్మాన్ టీవీ కార్యక్రమాలు చూడటం, క్రికెట్‌ను అనుసరించడం మరియు డేటా అనలిటిక్స్ గురించి చదవడం ఆనందించేవాడు.
ఉస్మాన్ ఘనీ నుండి మరిన్నిమా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి
టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!
సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి