లో తీగలను జావా మార్పులేని అక్షరాల క్రమం. మరోవైపు, మార్చగల అక్షరాల క్రమాన్ని సృష్టించడానికి స్ట్రింగ్‌బఫర్ ఉపయోగించబడుతుంది. ఈ వ్యాసంలో మేము జావాలో స్ట్రింగ్‌బఫర్ భావనలోకి లోతుగా మునిగిపోతాము. ఈ సెషన్‌లో క్రింది పాయింటర్లు చర్చించబడతాయి,
కాబట్టి మనం ప్రారంభిద్దాం, అయితే, మేము కొంతమంది కన్స్ట్రక్టర్లతో ప్రారంభించడం ముఖ్యం,
కన్స్ట్రక్టర్లు
ఖాళీ స్ట్రింగ్‌బఫర్
16 అక్షరాల ప్రారంభ సామర్థ్యంతో ఖాళీ స్ట్రింగ్ బఫర్ సృష్టించబడుతుంది.
స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ()
ఆర్గ్యుమెంట్ స్ట్రింగ్ బఫర్
సృష్టించిన స్ట్రింగ్ బఫర్ వాదనలో పేర్కొన్న పరిమాణంలో ఉంటుంది.
స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ (20)
Str స్ట్రింగ్‌బఫర్
పేర్కొన్న వాదన స్ట్రింగ్‌బఫర్ ఆబ్జెక్ట్ యొక్క ప్రారంభ విషయాలను సెట్ చేస్తుంది మరియు తిరిగి కేటాయించకుండా మరో 16 అక్షరాల కోసం స్థలాన్ని రిజర్వు చేస్తుంది.
స్ట్రింగ్‌బఫర్ str = క్రొత్త స్ట్రింగ్‌బఫర్ (“స్వాగతం”)
జావా వ్యాసంలో స్ట్రింగ్‌బఫర్‌తో కొనసాగిద్దాం,
పద్ధతులు
స్ట్రింగ్‌బఫర్‌లో ఉపయోగించిన పద్ధతులు ఈ క్రింది విధంగా పేర్కొనబడ్డాయి:
జావాలో స్ట్రింగ్‌బఫర్: పొడవు ()
ఇది ప్రస్తుతం ఉన్న మూలకాల సంఖ్యను నిర్దేశిస్తుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('జాన్‌డో') int q = str.length () System.out.println ('పొడవు:' + q )}}అవుట్పుట్:
పొడవు: 7
సామర్థ్యం ():
ఈ పద్ధతిని ఉపయోగించి స్ట్రింగ్‌బఫర్ సామర్థ్యాన్ని కనుగొనవచ్చు.
క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('జాన్‌డో') int q = str.capacity () System.out.println ('సామర్థ్యం:' + q)}}అవుట్పుట్:
సామర్థ్యం: 23
జావాలో స్ట్రింగ్‌బఫర్: జోడించు ():
ఈ పద్ధతి స్ట్రింగ్‌బఫర్ చివరిలో మూలకాలను జోడించడానికి ఉపయోగించబడుతుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('జాన్') str.append ('డో') System.out.println (str) // ఒక జతచేస్తుంది స్ట్రింగ్ str.append (5) System.out.println (str) // ఒక సంఖ్యను జోడిస్తుంది}}అవుట్పుట్:
జాన్ డో
జాన్ డో 5
చొప్పించు ():
పేర్కొన్న సూచిక స్థానంలో ఒక మూలకాన్ని చొప్పించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = క్రొత్త స్ట్రింగ్‌బఫర్ ('రాక్‌రోల్') str.insert (4, 'మరియు') System.out.println (str) str. చొప్పించు (0, 5) System.out.println (str) str.insert (5, 69.70d) System.out.println (str) str.insert (6, 69.42f) System.out.println (str) char arr [] = {'h', 's', 'w', 'p', 'a'} str.insert (2, arr) System.out.println (str)}}అవుట్పుట్:
కిందామీద
5 రాకండ్‌రోల్
5 రాక్ 69.7 మరియు రోల్
ఒక టేబుల్ లోపల html టేబుల్
5 రాక్ 669.429.7 మరియు రోల్
5Rhswpaock669.429.7andRoll
జావాలో స్ట్రింగ్‌బఫర్: రివర్స్ ():
స్ట్రింగ్‌బఫర్‌లో ఉన్న మూలకాలను రివర్స్ చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('రాకండ్‌రోల్') str.reverse () System.out.println (str)}}అవుట్పుట్:
lloRdnakcoR
తొలగించు (int startIndex, int endIndex)
స్ట్రింగ్‌బఫర్‌లో ఉన్న అంశాలను తొలగించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. తొలగించాల్సిన మొదటి అక్షరం మొదటి సూచిక ద్వారా పేర్కొనబడింది. StartIndex మరియు endIndex-1 మధ్య ఉన్న అంశాలు తొలగించబడతాయి.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('రాక్అండ్రోల్') str.delete (0, 4) System.out.println (str)}}అవుట్పుట్:
ఆండ్రోల్
జావాలో స్ట్రింగ్‌బఫర్: deleteCharAt (పూర్ణాంక సూచిక)
ఈ పద్ధతి స్ట్రింగ్‌బఫర్‌లో ఉన్న స్ట్రింగ్‌లోని ఒకే అక్షరాన్ని తొలగిస్తుంది. పూర్ణాంక సూచిక అక్షరం యొక్క స్థానాన్ని నిర్దేశిస్తుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('రాక్‌ఆండ్‌రోల్') str.deleteCharAt (5) System.out.println (str)}}అవుట్పుట్:
రాక్ఆడ్రోల్
భర్తీ ()
స్ట్రింగ్‌బఫర్ లోపల మూలకాలు లేదా అక్షరాల సమితిని మరొక దానితో భర్తీ చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. ఈ పద్ధతిలో స్టార్ట్ఇండెక్స్ మరియు ఎండ్ఇండెక్స్ వాదనలు ఉన్నాయి. స్టార్ట్ఇండెక్స్ నుండి ఎండ్ఇండెక్స్ -1 వరకు సబ్‌స్ట్రింగ్ భర్తీ చేయబడుతుంది.
దిగుమతి java.io. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('రాక్‌ఆండ్‌రోల్') str.replace (4, 7, 'లేదా') System.out.println (str) }}అవుట్పుట్:
రాక్నోర్ రోల్
sureCapacity ()
ఈ పద్ధతి ద్వారా స్ట్రింగ్‌బఫర్ సామర్థ్యాన్ని పెంచవచ్చు. క్రొత్త సామర్థ్యం వినియోగదారు పేర్కొన్న విలువ, లేదా పరిమాణాన్ని బట్టి ప్రస్తుత సామర్థ్యం ప్లస్ 2.
ఉదాహరణ: 16 ప్రస్తుత సామర్థ్యం అయితే: (16 * 2) +2.
క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ () System.out.println (str.capacity ()) // ప్రారంభ సామర్థ్యం str.append ('రాక్') System.out.println (str.capacity ()) // ఇప్పుడు 16 str.append ('నా పేరు జాన్ డో') System.out.println (str.capacity ()) // (oldcapacity * 2) +2 str.ensureCapacity (10) // మార్పు లేదు System.out.println (str.capacity ()) str.ensureCapacity (50) // ఇప్పుడు (34 * 2) +2 System.out.println (str.capacity ()) // ఇప్పుడు 70}}అవుట్పుట్:
16
16
3. 4
3. 4
70
స్ట్రింగ్‌బఫర్ appendCodePoint (int codePoint)
ఈ పద్ధతిలో కోడ్ పాయింట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యం స్ట్రింగ్‌బఫర్‌లో ఉన్న అక్షరాలకు జోడించబడుతుంది.
java.lang ను దిగుమతి చేయండి. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ str = కొత్త స్ట్రింగ్‌బఫర్ ('రాక్‌ఆండ్‌రోల్') System.out.println ('స్ట్రింగ్‌బఫర్:' + str) // కోడ్‌పాయింట్‌ను జోడించడం స్ట్రింగ్ str.appendCodePoint (70) System.out.println ('కోడ్‌పాయింట్‌తో స్ట్రింగ్‌బఫర్:' + str)}}అవుట్పుట్:
స్ట్రింగ్‌బఫర్: రాక్అండ్రోల్
కోడ్‌పాయింట్‌తో స్ట్రింగ్‌బఫర్: రాక్అండ్‌రోల్ఎఫ్
జావాలో స్ట్రింగ్‌బఫర్: int codePointAt (పూర్ణాంక సూచిక)
ఈ పద్ధతిలో అక్షరం యొక్క “యూనికోడెనంబర్” సూచిక వద్ద తిరిగి ఇవ్వబడుతుంది. సూచిక యొక్క విలువ 0 మరియు పొడవు -1 మధ్య ఉండాలి.
క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {// స్ట్రింగ్‌బఫర్ స్ట్రింగ్‌బఫర్‌ను సృష్టించడం s = కొత్త స్ట్రింగ్‌బఫర్ () s.append ('రాక్అండ్రోల్') // స్థానం 7 యొక్క యూనికోడ్‌ను పొందడం 7 పూర్ణాంకం యూనికోడ్ = s.codePointAt (7) // ఫలితాన్ని ప్రదర్శిస్తుంది System.out.println ('ఇండెక్స్ 7 వద్ద అక్షర యూనికోడ్:' + యూనికోడ్)}}అవుట్పుట్:
ఇండెక్స్ 7: 82 వద్ద అక్షరం యొక్క యూనికోడ్
స్ట్రింగ్ టూ స్ట్రింగ్ ()
ఈ ఇన్‌బిల్ట్ పద్ధతి స్ట్రింగ్‌బఫర్‌లో ఉన్న డేటాను సూచించే స్ట్రింగ్‌ను అందిస్తుంది. స్ట్రింగ్‌బఫర్ ఆబ్జెక్ట్ నుండి అక్షర క్రమాన్ని పొందడానికి కొత్త స్ట్రింగ్ ఆబ్జెక్ట్ ప్రకటించబడింది మరియు ప్రారంభించబడింది. స్ట్రింగ్ సిస్ అప్పుడు toString () ద్వారా తిరిగి వచ్చింది.
java.lang ను దిగుమతి చేయండి. * క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్‌బఫర్ s = కొత్త స్ట్రింగ్‌బఫర్ ('రాక్‌ఆండ్‌రోల్') System.out.println ('స్ట్రింగ్:' + s.toString ())}}అవుట్పుట్:
స్ట్రింగ్: రాక్అండ్రోల్
జావాలో స్ట్రింగ్‌బఫర్: ట్రిమ్‌టోసైజ్ () ను రద్దు చేయండి
ట్రిమ్‌టోసైజ్ () అనేది అంతర్నిర్మిత పద్ధతి. అక్షర శ్రేణి యొక్క సామర్థ్యం ఈ పద్ధతిని ఉపయోగించడం ద్వారా కత్తిరించబడుతుంది.
java.lang ను దిగుమతి చేయండి. out.println ('కత్తిరించే ముందు సామర్థ్యం:' + s.capacity ()) // కత్తిరించడం s.trimToSize () // స్ట్రింగ్‌ను ప్రదర్శిస్తుంది System.out.println ('String =' + s.toString ()) // ప్రదర్శిస్తుంది కత్తిరించిన సామర్థ్యం System.out.println ('కత్తిరించిన తర్వాత సామర్థ్యం:' + s.capacity ())}}అవుట్పుట్:
కత్తిరించే ముందు సామర్థ్యం: 27
స్ట్రింగ్: రాక్అండ్‌రోల్‌పాప్
కత్తిరించిన తర్వాత సామర్థ్యం: 14
ఈ వ్యాసంలో పేర్కొన్న వివిధ పద్ధతులు జావాలోని స్ట్రింగ్‌బఫర్ క్లాస్‌తో అనుగుణంగా ఉపయోగించబడతాయి. ఈ పద్ధతులు సమర్థవంతంగా పనిచేస్తాయి మరియు తీగలను సులభంగా సవరించడానికి వినియోగదారుని అనుమతిస్తాయి.
ఈ విధంగా ‘జావాలోని స్ట్రింగ్‌బఫర్’ పై ఈ వ్యాసం ముగిసింది. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.