స్ట్రింగ్ మెథడ్స్ జావా



జావా స్ట్రింగ్

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

విషయ సూచిక

జావాలో స్ట్రింగ్ సృష్టిస్తోంది

మేము 2 వేర్వేరు పద్ధతులను ఉపయోగించి స్ట్రింగ్‌ను సృష్టించవచ్చు:

  • స్ట్రింగ్ అక్షరాలా ఉపయోగించడం
  • క్రొత్త కీవర్డ్‌ని ఉపయోగించడం

స్ట్రింగ్ అక్షరాలా ఉపయోగించి స్ట్రింగ్‌ను సృష్టించండి

ఇది సృష్టించడానికి అత్యంత ప్రత్యక్ష మార్గం స్ట్రింగ్ జావాలో. విలువను డబుల్ కోట్స్‌లో జతచేయడం ద్వారా మనం స్ట్రింగ్‌ను సృష్టించవచ్చు. ఇక్కడ స్ట్రింగ్ రకం యొక్క వేరియబుల్ “విలువ” “జావా భాష” అని పిలువబడే స్ట్రింగ్‌ను కలిగి ఉంది

String value = "Java language";

మేము స్ట్రింగ్ అక్షరాలా సృష్టించినప్పుడు, స్ట్రింగ్ ఉన్నట్లయితే JVM మొదట “స్ట్రింగ్ స్థిరమైన పూల్” లో తనిఖీ చేస్తుంది. ఇది ఉనికిలో లేకపోతే, JVM క్రొత్త స్ట్రింగ్ ఉదాహరణను సృష్టిస్తుంది, లేకపోతే పూల్ చేసిన ఉదాహరణకి సూచన మాత్రమే తిరిగి ఇవ్వబడుతుంది. ఉదాహరణకు, ఈ క్రింది సందర్భంలో, రెండు స్ట్రింగ్ వస్తువులు ఒకే విలువను కలిగి ఉంటాయి. అందువల్ల 1 వస్తువు మాత్రమే సృష్టించబడుతుంది (అనగా s1) మరియు s2 కు s1 కు సూచన ఉంటుంది. దీని అర్థం, ఒకే విలువతో మనం ఎన్ని స్ట్రింగ్ వేరియబుల్స్‌తో సంబంధం లేకుండా, స్ట్రింగ్ స్థిరమైన పూల్‌లో 1 ఉదాహరణ మాత్రమే సృష్టించబడుతుంది.

“స్ట్రింగ్ స్థిరమైన పూల్” అనేది స్ట్రింగ్ వస్తువులను పట్టుకునే ప్రత్యేక మెమరీ తప్ప మరొకటి కాదు.

String s1 = "Java language"; 
String s2 = "Java language";

జావాలో స్ట్రింగ్

క్రొత్త కీవర్డ్‌ని ఉపయోగించి స్ట్రింగ్‌ను సృష్టిస్తోంది

ఒకే స్ట్రింగ్ విలువను కలిగి ఉన్న 2 వేర్వేరు వస్తువులను కలిగి ఉండాలనుకున్నప్పుడు, అప్పుడు మేము ఉపయోగించి స్ట్రింగ్‌ను సృష్టిస్తాము కొత్త క్రింద వివరించిన విధంగా కీవర్డ్. ఈ సందర్భంలో, JVM కుప్ప మెమరీలో 2 వేర్వేరు స్ట్రింగ్ వస్తువులను సృష్టిస్తుంది

String s1 = new String("Java");
String s2 = new String("Java");

జావాలో స్ట్రింగ్

స్ట్రింగ్ మెథడ్స్ జావా

Java.lang.String క్లాస్ క్రింద వివరించిన విధంగా వివిధ స్ట్రింగ్ మానిప్యులేషన్స్ కోసం ఉపయోగించే వివిధ పద్ధతులకు మద్దతు ఇస్తుంది:

విధానం<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>పారామీటర్లు
చార్ చార్అట్ (పూర్ణాంక సూచిక)ఇన్పుట్ స్ట్రింగ్ యొక్క పేర్కొన్న సూచిక వద్ద అక్షరాన్ని అందిస్తుందిసూచిక - స్ట్రింగ్ యొక్క సూచిక విలువ
int codePointAt (పూర్ణాంక సూచిక)పేర్కొన్న సూచిక వద్ద అక్షరం యొక్క యూనికోడ్ విలువను అందిస్తుందిసూచిక - స్ట్రింగ్ యొక్క సూచిక విలువ
పూర్ణాంక కోడ్ పాయింట్ ముందు (పూర్ణాంక సూచిక)పేర్కొన్న సూచికకు ముందు ఉన్న అక్షరం యొక్క యూనికోడ్ విలువను చూపుతుందిసూచిక - స్ట్రింగ్ యొక్క సూచిక విలువ
int పోల్చడానికి (స్ట్రింగ్ మరొక స్ట్రింగ్)అక్షరాల యూనికోడ్ విలువ ఆధారంగా 2 తీగలను పోల్చి, ఆర్గ్యుమెంట్ స్ట్రింగ్‌కు ముందు ఉంటే ప్రతికూల విలువను ఇస్తుంది, లేకపోతే పాజిటివ్ తిరిగి వస్తుంది. రెండు తీగలను సమానంగా ఉంటే తిరిగి వచ్చే విలువ 0anotherstring - స్ట్రింగ్ ఆబ్జెక్ట్‌తో పోల్చడానికి స్ట్రింగ్
పూర్ణాంకం టోఇగ్నోర్ కేస్ (స్ట్రింగ్ మరొక స్ట్రింగ్)పోల్చడానికి పద్ధతి మాదిరిగానే ఇది కేసును విస్మరిస్తుంది.anotherstring - స్ట్రింగ్ ఆబ్జెక్ట్‌తో పోల్చడానికి స్ట్రింగ్
స్ట్రింగ్ కాంకాట్ (స్ట్రింగ్ స్ట్రింగ్)రెండు స్ట్రింగ్ విలువలను కలుస్తుందిstr - స్ట్రింగ్ ఆబ్జెక్ట్ విలువతో కలిసిపోయే స్ట్రింగ్
బూలియన్ కలిగి ఉంది (చార్‌సక్వెన్స్ సి)స్ట్రింగ్ పేర్కొన్న అక్షర క్రమాన్ని కలిగి ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిc - స్ట్రింగ్‌లో కనుగొనడానికి అక్షర క్రమం
బూలియన్ కంటెంట్ఎక్వాల్స్ (చార్‌సక్వెన్స్ సి)స్ట్రింగ్ ఖచ్చితమైన అక్షరక్రమాన్ని కలిగి ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిc - స్ట్రింగ్‌లో కనుగొనడానికి అక్షర క్రమం
బూలియన్ కంటెంట్ఎక్వాల్స్ (స్ట్రింగ్‌బఫర్ ఎస్బి)స్ట్రింగ్ పేర్కొన్న స్ట్రింగ్ బఫర్‌ను కలిగి ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిsb - స్ట్రింగ్ బఫర్ కంటెంట్
బూలియన్ చివరలతో (స్ట్రింగ్ ప్రత్యయం)పేర్కొన్న ప్రత్యయంతో స్ట్రింగ్ ముగుస్తుందో లేదో తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిప్రత్యయం - స్ట్రింగ్‌లో తనిఖీ చేయడానికి ప్రత్యయం
బూలియన్ సమానం (ఆబ్జెక్ట్ ఆబ్జెక్ట్)ఆమోదించిన వస్తువుతో స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క సారూప్యతను తనిఖీ చేస్తుంది మరియు సమానంగా ఉంటే నిజం అవుతుందిobj - పోల్చడానికి వస్తువు
బూలియన్ సమానంఇగ్నోర్ కేస్ (స్ట్రింగ్ స్ట్రింగ్)కేసును విస్మరించడం ద్వారా సంబంధం లేకుండా రెండు స్ట్రింగ్‌ను పోల్చి, రెండు తీగలను సమానంగా ఉంటే నిజం అవుతుందిstr - పోల్చడానికి స్ట్రింగ్
int indexOf (int ch)స్ట్రింగ్‌లో పేర్కొన్న యునికోడ్ అక్షరం యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుందిch - అక్షరం యొక్క యూనికోడ్ విలువ
int indexOf (స్ట్రింగ్ str)స్ట్రింగ్‌లో పేర్కొన్న సబ్‌స్ట్రింగ్ యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుందిstr - స్ట్రింగ్‌లో ఉన్న సబ్‌స్ట్రింగ్ విలువ
బూలియన్ isBlank ()స్ట్రింగ్ ఖాళీగా ఉంది లేదా ఖాళీ స్థలాలను మాత్రమే కలిగి ఉంది
బూలియన్ isEmpty ()స్ట్రింగ్ ఖాళీగా ఉంటే నిజం అవుతుంది (అనగా పొడవు 0)
int lastindexOf (int ch)స్ట్రింగ్‌లో పేర్కొన్న యునికోడ్ అక్షరం యొక్క చివరి సంఘటన యొక్క సూచికను అందిస్తుందిch - అక్షరం యొక్క యూనికోడ్ విలువ
int lastindexOf (స్ట్రింగ్ str)స్ట్రింగ్‌లో పేర్కొన్న సబ్‌స్ట్రింగ్ యొక్క చివరి సంఘటన యొక్క సూచికను అందిస్తుందిstr - స్ట్రింగ్‌లో ఉన్న సబ్‌స్ట్రింగ్ విలువ
పూర్ణాంక పొడవు ()స్ట్రింగ్ యొక్క పొడవును అందిస్తుంది
బూలియన్ మ్యాచ్‌లు (స్ట్రింగ్ రీజెక్స్)పేర్కొన్న రెగ్యులర్ వ్యక్తీకరణతో స్ట్రింగ్ సరిపోలితే నిజం అవుతుందిregex - తనిఖీ చేయవలసిన సాధారణ వ్యక్తీకరణ
స్ట్రింగ్ రిపీట్ (పూర్ణాంక గణన)గణన ఆధారంగా స్ట్రింగ్‌ను కలుస్తుందిలెక్కింపు - ఇన్పుట్ స్ట్రింగ్ను కలపడానికి ఎన్నిసార్లు
స్ట్రింగ్ రీప్లేస్ (చార్ ఓల్డ్‌చార్, చార్ న్యూచార్)పాత్ర యొక్క అన్ని సంఘటనలను క్రొత్త అక్షరంతో భర్తీ చేయడం ద్వారా క్రొత్త స్ట్రింగ్‌ను అందిస్తుందిoldchar - భర్తీ చేయడానికి అక్షరం
newchar - మార్చవలసిన అక్షరం
స్ట్రింగ్ [] స్ప్లిట్ (స్ట్రింగ్ రిగెక్స్ప్)సాధారణ వ్యక్తీకరణ ఆధారంగా స్ట్రింగ్‌ను విభజిస్తుంది. ఇది శ్రేణిని అందిస్తుందిregexp - స్ట్రింగ్‌ను విభజించడానికి డీలిమిటర్
స్ట్రింగ్ [] స్ప్లిట్ (స్ట్రింగ్ రీగెక్స్, పూర్ణాంక పరిమితి)రెగ్యులర్ ఎక్స్‌ప్రెషన్ మరియు స్ట్రింగ్‌ను ఎన్నిసార్లు ఉపయోగించాలో దాని ఆధారంగా విభజిస్తుందిregexp - స్ట్రింగ్‌ను విభజించడానికి డీలిమిటర్
పరిమితి - నమూనా ఎన్నిసార్లు వర్తించాలి
బూలియన్ ప్రారంభమవుతుంది (స్ట్రింగ్ ఉపసర్గ)ఇచ్చిన స్ట్రింగ్ పేర్కొన్న ఉపసర్గతో ప్రారంభమైతే తనిఖీ చేస్తుంది. ఉన్నట్లయితే నిజమైనదిఉపసర్గ - స్ట్రింగ్‌లో తనిఖీ చేయడానికి ఉపసర్గ
బూలియన్ మొదలవుతుంది (స్ట్రింగ్ ఉపసర్గ, పూర్ణాంకం చాలా)ఇచ్చిన స్ట్రింగ్ టూఫ్‌సెట్ పరామితి ఆధారంగా పేర్కొన్న ఉపసర్గతో ప్రారంభమవుతుందో లేదో తనిఖీ చేస్తుంది. ఉన్నట్లయితే నిజమైనదిఉపసర్గ - స్ట్రింగ్‌లో తనిఖీ చేయడానికి ఉపసర్గ
tooffset - శోధనను ప్రారంభించాల్సిన సూచిక
స్ట్రింగ్ స్ట్రిప్ ()ప్రముఖ మరియు వెనుకంజలో ఉన్న అన్ని వైట్‌స్పేస్‌లను తీసివేసిన స్ట్రింగ్‌ను అందిస్తుంది
స్ట్రింగ్ స్ట్రిప్ లేడింగ్ ()అన్ని ప్రముఖ ఖాళీలు తీసివేయబడిన స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది
స్ట్రింగ్ స్ట్రిప్ట్రైలింగ్ ()అన్ని వెనుకంజలో ఉన్న ఖాళీలతో స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది
చార్‌సక్వెన్స్ సబ్‌క్వెన్స్ (int startIndex, int endIndex)ప్రారంభ మరియు ముగింపు సూచిక ఆధారంగా స్ట్రింగ్ యొక్క అక్షర క్రమాన్ని అందిస్తుందిstartIndex - సబ్‌స్ట్రింగ్ తిరిగి పొందవలసిన సూచిక
endIndex - సబ్‌స్ట్రింగ్ తిరిగి పొందవలసిన సూచిక
స్ట్రింగ్ సబ్ స్ట్రింగ్ (int startIndex)ప్రారంభ సూచిక ఆధారంగా స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుందిstartIndex - సబ్‌స్ట్రింగ్ తిరిగి పొందవలసిన సూచిక
స్ట్రింగ్ సబ్ స్ట్రింగ్ (int startIndex, int endIndex)ప్రారంభ మరియు ముగింపు సూచిక ఆధారంగా స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుందిstartIndex - సబ్‌స్ట్రింగ్ తిరిగి పొందవలసిన సూచిక
endIndex - సబ్‌స్ట్రింగ్ తిరిగి పొందవలసిన సూచిక
చార్ [] కు చార్అర్రే ()స్ట్రింగ్‌ను అక్షర శ్రేణికి మారుస్తుంది
స్ట్రింగ్ టు లోవర్ కేస్ ()స్ట్రింగ్‌లోని అన్ని అక్షరాలను చిన్న అక్షరాలకు మారుస్తుంది
స్ట్రింగ్ టు లోవర్ కేస్ (లొకేల్ లొకేల్)లొకేల్ నిబంధనల ఆధారంగా స్ట్రింగ్‌లోని అన్ని అక్షరాలను చిన్న అక్షరాలకు మారుస్తుందిలొకేల్ - వర్తించవలసిన లొకేల్ నియమాలు
స్ట్రింగ్ toString ()స్ట్రింగ్‌ను తిరిగి ఇస్తుంది
స్ట్రింగ్ టు అప్పర్‌కేస్ ()స్ట్రింగ్‌లోని అన్ని అక్షరాలను అప్పర్ కేస్‌గా మారుస్తుంది
స్ట్రింగ్ టు అప్పర్‌కేస్ (లొకేల్ లొకేల్)లొకేల్ నిబంధనల ఆధారంగా స్ట్రింగ్‌లోని అన్ని అక్షరాలను అప్పర్ కేస్‌గా మారుస్తుందిలొకేల్ - వర్తించవలసిన లొకేల్ నియమాలు
స్ట్రింగ్ ట్రిమ్ ()అన్ని ప్రముఖ మరియు వెనుకంజలో ఉన్న ఖాళీలు తీసివేయబడిన స్ట్రింగ్‌ను అందిస్తుంది
స్ట్రింగ్ ఫార్మాట్ స్ట్రింగ్ (స్ట్రింగ్ ఫార్మాట్, ఆబ్జెక్ట్ ... అర్గ్స్)ఫార్మాట్ మరియు ఆర్గ్యుమెంట్‌ల ఆధారంగా ఫార్మాట్ చేసిన స్ట్రింగ్‌ను అందిస్తుందిఫార్మాట్ - ఫార్మాట్ స్పెసిఫైయర్
అర్గ్స్ - ఫార్మాట్ స్పెసిఫైయర్ చేత సూచించబడిన వాదనలు
స్ట్రింగ్ జాయిన్ (చార్‌సక్వెన్స్ డీలిమిటర్, చార్‌సక్వెన్స్ ... ఎలిమెంట్స్)డీలిమిటర్ ఉపయోగించి అక్షర శ్రేణి మూలకాలలో కలుస్తుందిడీలిమిటర్ - చేరడానికి డీలిమిటర్
మూలకాలు - చేరడానికి స్ట్రింగ్ అంశాలు
స్ట్రింగ్ విలువఆఫ్ (బూలియన్ బి)బూలియన్ ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది. నిజం ఆమోదించబడితే, నిజమైనది తిరిగి వస్తుందిb - బూలియన్ విలువ నిజం లేదా తప్పు
స్ట్రింగ్ విలువఆఫ్ (చార్ సి)అక్షర వాదన యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిసి - అక్షరం
స్ట్రింగ్ విలువఆఫ్ (చార్ [] డేటా)అక్షర శ్రేణి వాదన యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిడేటా - అక్షర శ్రేణి
స్ట్రింగ్ విలువఆఫ్ (డబుల్ డి)డబుల్ ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిd - డబుల్ విలువ
స్ట్రింగ్ విలువఆఫ్ (ఫ్లోట్ ఎఫ్)ఫ్లోట్ ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిf - ఫ్లోట్ విలువ
స్ట్రింగ్ విలువఆఫ్ (int i)పూర్ణాంక వాదన యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిi - పూర్ణాంక విలువ
స్ట్రింగ్ విలువఐఎఫ్ (పొడవైన ఎల్)దీర్ఘ వాదన యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిl - దీర్ఘ విలువ
స్ట్రింగ్ విలువఆఫ్ (ఆబ్జెక్ట్ ఆబ్జెక్ట్)ఆబ్జెక్ట్ ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిobj - వస్తువు
స్ట్రింగ్ విలువఆఫ్ (చార్ [] డేటా, పూర్ణాంక ఆఫ్‌సెట్, పూర్ణాంక గణన)ఆఫ్‌సెట్ మరియు గణన ఆధారంగా నిర్దిష్ట సబ్‌స్ట్రింగ్ క్యారెక్టర్ అర్రే ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుందిడేటా - అక్షర శ్రేణి
ఆఫ్‌సెట్ - సూచికను ప్రారంభించండి
లెక్కింపు - సబ్‌స్ట్రింగ్ యొక్క పొడవు

ఉదాహరణ: శ్రేణి అక్షరాల నుండి స్ట్రింగ్ సృష్టించడానికి జావా ప్రోగ్రామ్

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

public class StringDemo1 {

  public static void main(String[] args) {
    char[] c = {'j','a','v','a'};
    String s = new String(c);
    System.out.println(s);
    
  }

}
Output:
java

ఉదాహరణ: పొడవు (), చార్అట్ () మరియు ఇండెక్స్ఆఫ్ () పద్ధతులను ఉపయోగించడం

కింది ఉదాహరణ ఒక నిర్దిష్ట సూచిక వద్ద అక్షరాన్ని ఎలా తిరిగి పొందాలో, స్ట్రింగ్ యొక్క పొడవును ఎలా పొందాలో మరియు ఒక నిర్దిష్ట అక్షరం యొక్క సూచికను తిరిగి పొందడం ఎలాగో మీకు చూపిస్తుంది.

public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("The character at index 6 is : " + s1.charAt(6));
    System.out.println("The length of the input string is : " + s1.length());
    System.out.println("The index of letter 'v' is : " + s1.indexOf('v'));
  }

}
Output:
The character at index 6 is : u
The length of the input string is : 13
The index of letter 'v' is : 2

ఉదాహరణ: పోల్చడానికి (), కంటెంట్ఎక్వాల్స్ () ను కలిగి ఉంది మరియు ()

ఈ ఉదాహరణ జావాలోని 2 తీగల పోలికను చూపిస్తుంది

  1. ఇన్పుట్ స్ట్రింగ్ ఆర్గ్యుమెంట్ స్ట్రింగ్ విజయవంతం అయినందున పోల్చండి () ఇక్కడ సానుకూల పూర్ణాంకాన్ని అందిస్తుంది.
  2. కేసుతో సంబంధం లేకుండా రెండు తీగలను సమానంగా ఉన్నందున పోల్చండి టోఇగ్నోర్ కేస్ () 0 ఇస్తుంది.
  3. ఇన్పుట్ స్ట్రింగ్ ఆర్గ్యుమెంట్ స్ట్రింగ్ కలిగి ఉన్నందున () నిజం అవుతుంది
  4. ఇన్పుట్ స్ట్రింగ్ ఖచ్చితమైన ఆర్గ్యుమెంట్ స్ట్రింగ్ కలిగి లేనందున contentEquals () తప్పుగా వస్తుంది.
public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("Comparison of input string with argument is : " + s1.compareTo("C++"));
    System.out.println("Comparison of input string with argument ignoring case is : " + s1.compareToIgnoreCase("JAVA TUTORIAL"));
    System.out.println("Output of contains method: " + s1.contains("tutorial"));
    System.out.println("Output of contentEquals method: " + s1.contentEquals("Java"));
    }
}
Output:
Comparison of input string with argument is : 7
Comparison of input string with argument ignoring case is : 0
Output of contains method: true
Output of contentEquals method: false

ఉదాహరణ: సమానంగా ఉపయోగించడం ()

1 వ అవుట్పుట్ తప్పు, ఎందుకంటే కంటెంట్ ఒకేలా ఉన్నప్పటికీ కేసు సరిపోలడం లేదు. కంటెంట్ మరియు కేస్ సరిపోలినందున 2 వ అవుట్పుట్ నిజం.

రెండు కంటెంట్ భిన్నంగా ఉన్నందున 3 వ అవుట్పుట్ తప్పు.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    String s2 = "Java Tutorial";
    String s3 = "java tutorial";
    String s4 = "Tutorial cup";
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    System.out.println(s1.equals(s4));
  }

}
Output:
false
true
false

ఉదాహరణ: తీగల సంయోగం

మేము కాంకట్ () ను ఉపయోగించి జావాలో 2 తీగలను సంగ్రహించవచ్చు. జావా యొక్క పద్ధతి స్ట్రింగ్ క్లాస్. సాధారణంగా ప్రింట్ స్టేట్మెంట్లలో ఉపయోగించే 2 లేదా అంతకంటే ఎక్కువ తీగలను కలిపేందుకు “+” ఉపయోగించబడుతుంది. 2 తీగలను కలిపేటప్పుడు, తీగల మధ్య స్థలం చేర్చబడలేదు. దిగువ ఉదాహరణలో, స్ట్రింగ్ ఎస్ 3 లో ఎస్ 1 మరియు ఎస్ 2 యొక్క సంక్షిప్త విలువ ఉంది, ఇది ప్రింట్ స్టేట్మెంట్‌లో కొత్త స్ట్రింగ్‌తో పాటు ఉపయోగించబడుతుంది.

జాయిన్ () పద్ధతిని ఉపయోగించి మేము జావాలో 2 తీగలను సంగ్రహించవచ్చు. ఇది పేర్కొన్న డీలిమిటర్‌తో వాదనలో పంపిన పదాలతో కలుస్తుంది.

public class StringConcat {

  public static void main(String[] args) {
    String s1 = "Hello,";
    String s2 = "how are you";
    String s3 = s1.concat(s2);
    System.out.println(s3 + " today");
    System.out.println(s1.join(",", "welcome","to","tutorialcup"));
  }

}
Output:
Hello,how are you today
welcome,to,tutorialcup

ఉదాహరణ: అప్పర్ కేస్ మరియు లోయర్ కేస్ మధ్య స్ట్రింగ్ మార్చడానికి జావా ప్రోగ్రామ్

public class StringCase {

  public static void main(String[] args) {
    String s1 = "Welcome to tutorialcup";
    System.out.println("Convert to lower case: " + s1.toLowerCase());
    System.out.println("Convert to upper case: " + s1.toUpperCase());

  }

}
Output:
Convert to lower case: welcome to tutorialcup
Convert to upper case: WELCOME TO TUTORIALCUP

ఉదాహరణ: జావాలో సబ్‌స్ట్రింగ్ ఉపయోగించడం

మేము ఉపయోగించి జావాలోని స్ట్రింగ్ యొక్క కొంత భాగాన్ని తిరిగి పొందవచ్చు సబ్‌స్ట్రింగ్ పద్ధతి. సూచిక విలువ 0 వద్ద ప్రారంభమవుతుంది.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    System.out.println(s1.substring(3));
    System.out.println(s1.substring(1, 10));
  }

}
Output:
a tutorial
ava tutor

ఉదాహరణ: స్ప్లిట్ ఉపయోగించి మరియు భర్తీ చేయండి

జావాలో స్ట్రింగ్ యొక్క సాధారణంగా ఉపయోగించే మరొక పద్ధతి స్ప్లిట్. ఈ ఉదాహరణలో, మేము మొదట ఇన్పుట్ స్ట్రింగ్‌ను డీలిమిటర్ ఉపయోగించి విభజించాము ”“. అందువల్ల ఇది ప్రతి పదాన్ని విడిగా ప్రింట్ చేస్తుంది. తరువాత, మేము డీలిమిటర్ ఆధారంగా విడిపోతాము కాని పరిమితిని 2 గా పేర్కొనండి అంటే రెండు స్ట్రింగ్ అర్రే విలువలుగా మాత్రమే విభజిస్తుంది.

భర్తీ చేసే 1 వ ఉదాహరణలో, మేము వ్యక్తిగత అక్షరాన్ని భర్తీ చేస్తాము. తరువాత, మేము అక్షర క్రమాన్ని భర్తీ చేస్తాము.

public class StringDemo4 {

  public static void main(String[] args) {
    String str1 = "Welcome to java programming";
    System.out.println("Split output using delimiter:");
    //Split using only delimiter
    String[] arrval = str1.split(" ");
    for(int i=0;i<arrval.length;i++) {
      System.out.println(arrval[i]);
    }
    System.out.println("\nSplit output using delimiter and limit:");
    //Split using delimiter and limit
    String[] arrval2 = str1.split(" ", 2);
    for(int i=0;i<arrval2.length;i++) {
      System.out.println(arrval2[i]);
    }
    
    System.out.println("\nReplace output with character:");
    //Replace character
    String str2 = str1.replace('j', 'J');
    System.out.println(str2);
    System.out.println("\nReplace output with character sequence:");
    String str3 = str1.replace("java", "javascript");
    System.out.println(str3);
  }

}


Output:
Split output using delimiter:
Welcome
to
java
programming

Split output using delimiter and limit:
Welcome
to java programming

Replace output with character:
Welcome to Java programming

Replace output with character sequence:
Welcome to javascript programming

ఉదాహరణ: జావా ఫార్మాట్ స్ట్రింగ్

మేము ఏదైనా ఫార్మాట్ చేయవచ్చు డేటా రకం ఫార్మాట్ పద్ధతిని ఉపయోగించి స్ట్రింగ్‌కు. ఇక్కడ, మేము స్ట్రింగ్ (“% s”), ఫ్లోట్ (% f ”) మరియు బూలియన్ (“% b ”) ని ఉదాహరణలుగా ఉపయోగిస్తున్నాము.

public class StringFormat {

  public static void main(String[] args) {
    String str = "Java";
    String formatstring1 = String.format("Programming language is %s",str);
    String formatstring2 = String.format("Float value is %f", 55.6789);
    String formatstring3 = String.format("Boolean value is %b", true);
    System.out.println(formatstring1);
    System.out.println(formatstring2);
    System.out.println(formatstring3);
  }

}
Output:
Programming language is Java
Float value is 55.678900
Boolean value is true

ముగింపు

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

సూచన