ఈ ట్యుటోరియల్ జావాలో స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తొలగించే పద్ధతిని ప్రత్యేకంగా చర్చిస్తుంది.
జావాలో స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని ఎలా తొలగించాలి?
జావాలో, మీరు ఉపయోగించి స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయవచ్చు:
- సబ్‌స్ట్రింగ్() పద్ధతి
- StringBuilder.deleteCharAt() పద్ధతి
- StringBuffer.delete() పద్ధతి
మేము ఇప్పుడు పైన పేర్కొన్న ప్రతి పద్ధతులను ఒక్కొక్కటిగా పరిశీలిస్తాము!
విధానం 1: సబ్‌స్ట్రింగ్() పద్ధతిని ఉపయోగించి స్ట్రింగ్‌లోని మొదటి అక్షరాన్ని తీసివేయండి
స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయడానికి, జావా స్ట్రింగ్ క్లాస్ 'ని ఉపయోగించండి సబ్‌స్ట్రింగ్() ” పద్ధతి. మీరు స్ట్రింగ్ యొక్క మొదటి మరియు చివరి అక్షరాన్ని ఒకేసారి తొలగించడానికి కూడా ఈ పద్ధతిని ఉపయోగించవచ్చు. స్ట్రింగ్‌లు మార్పులేనివి కాబట్టి, ఫలిత సబ్‌స్ట్రింగ్ కొత్త స్ట్రింగ్ టైప్ వేరియబుల్‌లో నిల్వ చేయబడాలి.
వాక్యనిర్మాణం
సబ్‌స్ట్రింగ్() పద్ధతి యొక్క సాధారణ వాక్యనిర్మాణం ఇలా ఇవ్వబడింది:
సబ్ స్ట్రింగ్ ( int ప్రారంభం, పూర్ణాంక ముగింపు )ఇక్కడ, సబ్‌స్ట్రింగ్() పద్ధతి రెండు పారామితులను తీసుకుంటుంది, ' ప్రారంభించండి 'మరియు' ముగింపు ”; రెండవ పరామితి ఐచ్ఛికం. ఈ పద్ధతి స్ట్రింగ్ యొక్క ప్రారంభ మరియు ముగింపు అక్షరాలను తీసివేస్తుంది మరియు ఫలిత సబ్‌స్ట్రింగ్‌ను అందిస్తుంది.
అయినప్పటికీ, మీరు స్ట్రింగ్‌లోని మొదటి అక్షరాన్ని మాత్రమే తీసివేయాలని భావిస్తే, మీరు ఈ క్రింది విధంగా ప్రారంభ సూచికను పాస్ చేయవచ్చు:
సబ్ స్ట్రింగ్ ( int ప్రారంభం )పేర్కొన్న భావనను అర్థం చేసుకోవడానికి క్రింద ఇవ్వబడిన ఉదాహరణను చూడండి.
ఉదాహరణ
మేము ' పేరుతో వేరియబుల్‌ని సృష్టిస్తాము str 'మరియు దాని విలువను ' ఉపయోగించి ముద్రించండి System.out.println() 'పద్ధతి:
స్ట్రింగ్ str = 'Linux' ;System.out.println ( 'అసలు స్ట్రింగ్:' + str ) ;
అప్పుడు, మేము పాస్ చేస్తాము ' 1 ''కి ప్రారంభ సూచిక పరామితిగా సబ్‌స్ట్రింగ్() ” పద్ధతి. ఈ ఆపరేషన్ మొదటిది మినహా ఒరిజినల్ స్ట్రింగ్‌లోని అన్ని అక్షరాలను కలిగి ఉన్న సబ్‌స్ట్రింగ్‌ను అందిస్తుంది:
స్ట్రింగ్ newStr = str.substring ( 1 ) ;చివరగా, ఫలిత స్ట్రింగ్‌ను ప్రదర్శించడానికి మేము System.out.println() పద్ధతిని మళ్లీ ఉపయోగిస్తాము:
System.out.println ( 'ఫలితం స్ట్రింగ్:' + newStr ) ; 
అవుట్‌పుట్ '' యొక్క మొదటి అక్షరాన్ని చూపిస్తుంది Linux ” స్ట్రింగ్ విజయవంతంగా తీసివేయబడింది మరియు సబ్‌స్ట్రింగ్() పద్ధతి తిరిగి వచ్చింది” inxhint ”:
విధానం 2: StringBuilder.deleteCharAt() పద్ధతిని ఉపయోగించి స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయండి
స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయడానికి మరొక పద్ధతి ' deleteCharAt() ” పద్ధతి. ఈ పద్ధతికి చెందినది ' స్ట్రింగ్ బిల్డర్ ” తరగతి. కొత్త ఆబ్జెక్ట్‌లను సృష్టించకుండానే, స్ట్రింగ్‌బిల్డర్ వినియోగదారుని స్ట్రింగ్‌ల నుండి అక్షరాలను జోడించడానికి లేదా తీసివేయడానికి అనుమతిస్తుంది ఎందుకంటే StringBuilder మార్చబడుతుంది.
వాక్యనిర్మాణం
“deleteCharAt()” పద్ధతి యొక్క సింటాక్స్ క్రింది విధంగా ఇవ్వబడింది:
deleteCharAt ( int సూచిక )ఇది ఒక పరామితిని మాత్రమే అంగీకరిస్తుంది మరియు పేర్కొన్న సూచికలో ఉన్న అక్షరాన్ని తొలగిస్తుంది.
ఉదాహరణ
మేము అదే స్ట్రింగ్‌ని ఉపయోగిస్తాము ' str ” అని పైన పేర్కొన్న ఉదాహరణలో సృష్టించబడింది. ఇప్పుడు, మేము '' అనే ఆబ్జెక్ట్‌ని సృష్టిస్తాము. sbStr 'స్ట్రింగ్‌బిల్డర్ క్లాస్ మరియు పాస్' str 'పరామితిగా:
StringBuilder sbStr = కొత్త StringBuilder ( str ) ;అప్పుడు, కాల్ చేయండి ' deleteCharAt() 'పద్ధతి మరియు పాస్' 0 ” ఇచ్చిన స్ట్రింగ్‌లోని మొదటి అక్షరాలను తీసివేయడానికి వాదనగా:
sbStr.deleteCharAt ( 0 ) ;చివరగా, 'ని ఉపయోగించి సబ్‌స్ట్రింగ్‌ను ప్రింట్ చేయండి System.out.println() 'పద్ధతి:
System.out.println ( 'స్ట్రింగ్ బిల్డర్‌ని ఉపయోగించడం ద్వారా ఫలిత స్ట్రింగ్:' + sbStr ) ; 
అవుట్‌పుట్
విధానం 3: StringBuffer.delete() పద్ధతిని ఉపయోగించి స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయండి
ది ' తొలగించు() 'పద్ధతి'కి చెందినది స్ట్రింగ్‌బఫర్ ” తరగతి. ఈ ' StringBuffer.delete() జావాలో స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయడానికి కూడా పద్ధతి ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
StringBuffer క్లాస్ యొక్క పద్ధతి తొలగింపు() యొక్క సింటాక్స్:
తొలగించు ( int startindex, int endindex )ఇది రెండు పారామితులను తీసుకుంటుంది, ' ప్రారంభ సూచిక 'మరియు' ముగింపు సూచిక ”, మరియు అందించిన పరిధిలో పేర్కొన్న అక్షరాలను తొలగించిన తర్వాత సబ్‌స్ట్రింగ్‌ను అందిస్తుంది.
ఉదాహరణ
మొదట, మేము '' అనే వస్తువును సృష్టిస్తాము. sbStr స్ట్రింగ్‌బఫర్ క్లాస్ యొక్క స్ట్రింగ్‌ను పాస్ చేయడం ద్వారా str ”అందులో వాదనగా:
StringBuffer sbStr = కొత్త StringBuffer ( str ) ;అప్పుడు, మేము '' అని పిలుస్తాము తొలగించు() 'పద్ధతి మరియు పాస్' 0 'ప్రారంభ సూచికగా మరియు' 1 ” ముగింపు సూచికగా:
sbStr.delete ( 0 , 1 ) ;చివరగా, కన్సోల్‌లో ఫలిత సబ్‌స్ట్రింగ్‌ను ప్రింట్ చేయండి:
System.out.println ( 'స్ట్రింగ్ బఫర్ ఉపయోగించి ఫలిత స్ట్రింగ్:' + sbStr ) ; 
మీరు చూడగలిగినట్లుగా, మేము '' యొక్క మొదటి అక్షరాన్ని విజయవంతంగా తొలగించాము. Linux తొలగింపు() పద్ధతిని ఉపయోగించి ” స్ట్రింగ్:
జావాలోని స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తీసివేయడానికి సంబంధించిన అన్ని ముఖ్యమైన సూచనలను మేము సంకలనం చేసాము.
ముగింపు
స్ట్రింగ్ మొదటి అక్షరాన్ని తీసివేయడానికి, మీరు మూడు పద్ధతులను ఉపయోగించవచ్చు: String.substring(), StringBuilder.deleteCharAt(), లేదా StringBuffer.delete() పద్ధతి. String.substring() ఇతర పేర్కొన్న పద్ధతుల కంటే చాలా వేగంగా ఉంటుంది. ఇది నవీకరించబడిన ప్రారంభ మరియు ముగింపు సూచికతో కొత్త స్ట్రింగ్‌ను అందిస్తుంది. ఈ ట్యుటోరియల్‌లో, జావాలో స్ట్రింగ్‌లోని మొదటి అక్షరాన్ని తొలగించే పద్ధతులను మేము వివరించాము.