విభజన కోడింగ్ చేసేటప్పుడు చాలా తరచుగా చేసే ఆపరేషన్. జావాలో స్ట్రింగ్‌ను విభజించడానికి చాలా మార్గాలు ఉన్నాయి కాని స్ట్రింగ్ స్ప్లిట్ () పద్ధతిని ఉపయోగించడం చాలా సాధారణ మార్గం. ఈ వ్యాసం ఉపయోగించి తీగలను ఎలా విభజించాలనే దానిపై దృష్టి పెట్టింది స్ప్లిట్ పద్ధతి లో .
ఈ వ్యాసంలో పొందుపరచబడిన విషయాలు క్రింద ఇవ్వబడ్డాయి:
- జావాలో స్ప్లిట్ మెథడ్
- పరిమితి పరామితి లేకుండా స్ప్లిట్ () పద్ధతిని ఉపయోగించడం
- పరిమితి పరామితితో స్ప్లిట్ () పద్ధతిని ఉపయోగించడం
జావాలో స్ప్లిట్ మెథడ్
ది స్ట్రింగ్ క్లాస్ జావాలో a స్ప్లిట్ () స్ట్రింగ్‌ను విభజించడానికి ఉపయోగించే పద్ధతి అమరిక సాధారణ వ్యక్తీకరణకు సరిపోయే డీలిమిటర్ల ఆధారంగా స్ట్రింగ్ వస్తువులు. ఉదాహరణకు, కింది స్ట్రింగ్ ఇవ్వబడింది:
స్ట్రింగ్ s = 'స్వాగతం, కు, ఎడురేకా!'
మీరు ఈ క్రింది కోడ్‌ను ఉపయోగించి స్ట్రింగ్‌ను ఉప-తీగలుగా విభజించవచ్చు:
స్ట్రింగ్ [] result = s.split (',')మరింత ఖచ్చితంగా, ఉప-తీగలను వేరుచేసిన చోట ఆ వ్యక్తీకరణ స్ట్రింగ్‌ను ఉప-తీగలుగా విచ్ఛిన్నం చేస్తుంది డీలిమిటర్ అక్షరాలు. పై ఉదాహరణలో, ఇన్పుట్ స్ట్రింగ్ ‘స్వాగతం, టు, ఎడురేకా’, మూడు స్ట్రింగ్ వస్తువులుగా విభజించబడింది, అవి:
స్వాగతం కు ఎడురేకా!లో స్ప్లిట్ () పద్ధతి యొక్క రెండు రకాలు ఉన్నాయి . వాటిలో ప్రతి దాని గురించి చర్చిద్దాం.
పరిమితి పరామితి లేకుండా స్ప్లిట్ () పద్ధతిని ఉపయోగించడం
యొక్క ఈ వేరియంట్ స్ప్లిట్ () పద్ధతి రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ను పరామితిగా అంగీకరిస్తుంది మరియు రెగ్యులర్ ఎక్స్‌ప్రెషన్ ఆధారంగా ఇచ్చిన స్ట్రింగ్‌ను విచ్ఛిన్నం చేస్తుంది regex . ఇక్కడ డిఫాల్ట్ పరిమితి 0. సింటాక్స్, పరామితి, తిరిగి విలువ, విసిరిన మరియు భావనను ప్రదర్శించే చాలా ఉదాహరణ కార్యక్రమాలు.
సింటాక్స్: పబ్లిక్ స్ట్రింగ్ [] స్ప్లిట్ (స్ట్రింగ్ రీజెక్స్)
పరామితి: రీగెక్స్ (డీలిమిటింగ్ రెగ్యులర్ ఎక్స్‌ప్రెషన్)
తిరిగి వచ్చే విలువ: S యొక్క శ్రేణి ట్రింగ్ వస్తువులు
మినహాయింపు: సరళి సింటాక్స్ ఎక్సెప్షన్ , అందించిన సాధారణ వ్యక్తీకరణ యొక్క వాక్యనిర్మాణం చెల్లదు
ఉదాహరణ 1: పిలుస్తున్నారు a స్ప్లిట్ () స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి - కామాతో విభజించడం
ప్యాకేజీ మైప్యాకేజ్ పబ్లిక్ క్లాస్ మెథడ్ 1 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ స్ట్రింగ్ = 'మేము, హాస్యాస్పదంగా, కట్టుబడి ఉన్నాము!' స్ట్రింగ్ [] arrOfStr = str.split (',') System.out.println ('సబ్‌స్ట్రింగ్‌ల సంఖ్య:' + arrOfStr.length) కోసం (int i = 0 i అవుట్పుట్
జావాలో సెషన్‌ను ఎలా సృష్టించాలి
సబ్‌స్ట్రింగ్‌ల సంఖ్య: 3 str [0]: మేము str [1]: హాస్యాస్పదంగా str [2]: కట్టుబడి ఉన్నాము!
ఉదాహరణ 2: పిలుస్తున్నారు a స్ప్లిట్ () స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి - వైట్‌స్పేస్ ద్వారా విభజించడం
ప్యాకేజీ MyPackage పబ్లిక్ క్లాస్ మెథడ్ 2 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str = 'మేము హాస్యాస్పదంగా కట్టుబడి ఉన్నాము! (Int i = 0 i) 'స్ట్రింగ్ [] arrOfStr = str.split (' ') System.out.println (' సబ్‌స్ట్రింగ్‌ల సంఖ్య: '+ arrOfStr.length) కు స్వాగతం. అవుట్పుట్
సబ్‌స్ట్రింగ్‌ల సంఖ్య: 4 str [0]: మేము str [1]: హాస్యాస్పదంగా str [2]: కట్టుబడి ఉన్నాము! str [3]: స్వాగతం
ఉదాహరణ 3: పిలుస్తున్నారు a స్ప్లిట్ () స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి - చుక్క ద్వారా విభజించడం
ప్యాకేజీ MyPackage పబ్లిక్ క్లాస్ మెథడ్ 3 {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str = 'మేము. రిడిక్యులస్.కమిటెడ్. స్వాగతం' స్ట్రింగ్ [] arrOfStr = str.split ('.') System.out.println ( (సబ్‌స్ట్రింగ్‌ల సంఖ్య: '+ arrOfStr.length) (int i = 0 i అవుట్పుట్
సబ్‌స్ట్రింగ్‌ల సంఖ్య: 4 str [0]: మేము str [1]: హాస్యాస్పదంగా str [2]: కట్టుబడి ఉన్న str [3]: స్వాగతం
ఉదాహరణ 4: పిలుస్తున్నారు a స్ప్లిట్ () స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి - అక్షరాన్ని ఉపయోగించడం ద్వారా విభజించడం
ప్యాకేజీ MyPackage పబ్లిక్ క్లాస్ మెథడ్ 4 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str = 'మేము హాస్యాస్పదంగా కట్టుబడి ఉన్నాము! (Int i = 0 i) కోసం 'స్ట్రింగ్ [] arrOfStr = str.split (' W ') System.out.println (' సబ్‌స్ట్రింగ్‌ల సంఖ్య: '+ arrOfStr.length) కు స్వాగతం. అవుట్పుట్
సబ్‌స్ట్రింగ్‌ల సంఖ్య: 3 str [0]: str [1]: e Are హాస్యాస్పదంగా కట్టుబడి ఉంది! str [2]: elcome
ఉదాహరణ 5: పిలుస్తున్నారు a స్ప్లిట్ () స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి - బహుళ డీలిమిటర్లచే విభజించడం
ప్యాకేజీ MyPackage పబ్లిక్ క్లాస్ మెథడ్ 5 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str = 'మేము, హాస్యాస్పదంగా కట్టుబడి ఉన్నాము! Eduerka.Hello 'String [] arrOfStr = str.split (' [,.!] + ') System.out.println (' సబ్‌స్ట్రింగ్‌ల సంఖ్య: '+ arrOfStr.length) కోసం (int i = 0 i అవుట్పుట్
సబ్‌స్ట్రింగ్‌ల సంఖ్య: 7 str [0]: మేము str [1]: హాస్యాస్పదంగా str [2]: కట్టుబడి ఉన్న str [3]: స్వాగతం str [4]: to str [5]: Eduerka str [6]: హలో
బాగా, ఇది చాలా సులభం, సరియైనదా? అయితే ఏమిస్ప్లిట్ ఆపరేషన్ తర్వాత మీకు మొదటి ‘ఎన్’ అంశాలు మాత్రమే అవసరమవుతాయి కాని మిగిలిన స్ట్రింగ్ అలాగే ఉండాలని కోరుకుంటున్నారా? దాని కోసం, మనకు s యొక్క మరొక వేరియంట్ ఉంది plit () పద్ధతి.
తో స్ప్లిట్ () పద్ధతిని ఉపయోగించడం పరిమితి పరామితి
స్ప్రింగ్ () పద్ధతి యొక్క ఈ వేరియంట్ స్ట్రింగ్‌ను పరిమిత సంఖ్యలో తీగలుగా విభజించాలనుకున్నప్పుడు ఉపయోగించబడుతుంది. స్ప్లిట్ () పద్ధతి యొక్క ఈ వేరియంట్ మరియు మరొకటి మధ్య ఉన్న తేడా ఏమిటంటే, విడిపోయిన తర్వాత తిరిగి వచ్చిన తీగల సంఖ్యను ఇది పరిమితం చేస్తుంది. పరిమితిని ఇన్పుట్ పరామితిగా ఇవ్వవచ్చు స్ప్లిట్ () పద్ధతి. పరిమితి పరామితి నమూనా ఎన్నిసార్లు వర్తింపజేస్తుందో నియంత్రిస్తుంది మరియు అందువల్ల వచ్చే శ్రేణి యొక్క పొడవును ప్రభావితం చేస్తుంది.
సింటాక్స్, పారామితి, రిటర్న్ వాల్యూ, విసిరిన మినహాయింపులు మరియు భావనను ప్రదర్శించే ఉదాహరణ ప్రోగ్రామ్‌లు క్రింద ఇవ్వబడ్డాయి.
సింటాక్స్: పబ్లిక్ స్ట్రింగ్ [] స్ప్లిట్ (స్ట్రింగ్ రీజెక్స్, పూర్ణాంక పరిమితి)
పరామితి:
- regex - డీలిమిటింగ్ రెగ్యులర్ వ్యక్తీకరణ
- పరిమితి - ఫలిత పరిమితి
పరిమితి 3 విలువలను కలిగి ఉంటుంది, అవి:
- పరిమితి> 0: పరిమితి సానుకూలంగా ఉంటే, అప్పుడు నమూనా చాలా పరిమితి -1 సార్లు వర్తించబడుతుంది. టిఅతను ఫలిత శ్రేణి యొక్క పొడవు n కంటే ఎక్కువ కాదు, మరియు శ్రేణి యొక్క చివరి ఎంట్రీ చివరి సరిపోలిన డీలిమిటర్‌కు మించిన అన్ని ఇన్‌పుట్‌లను కలిగి ఉంటుంది.
- పరిమితి<0: పరిమితి సానుకూలంగా ఉంటే, అప్పుడు నమూనా సాధ్యమైనంత ఎక్కువసార్లు వర్తించబడుతుంది మరియు ఫలిత శ్రేణి ఏదైనా పొడవు కలిగి ఉంటుంది.
- పరిమితి = 0: పరిమితి 0 కి సమానంగా ఉంటే, నమూనా సాధ్యమైనంత ఎక్కువసార్లు వర్తించబడుతుంది, ఫలిత శ్రేణికి ఏదైనా పొడవు ఉంటుంది, కానీ వెనుకంజలో ఉన్న ఖాళీ తీగలను విస్మరిస్తారు.
తిరిగి వచ్చే విలువ: యొక్క శ్రేణి స్ట్రింగ్ ఇచ్చిన స్ట్రింగ్‌ను బట్టి విభజించడం ద్వారా వస్తువులు లెక్కించబడతాయి పరిమితి పరామితి
మినహాయింపు: సరళి సింటాక్స్ ఎక్సెప్షన్ , అందించిన సాధారణ వ్యక్తీకరణ యొక్క వాక్యనిర్మాణం చెల్లదు
ఉదాహరణ: పిలుస్తున్నారు a స్ప్లిట్ () తో స్ట్రింగ్ ఆబ్జెక్ట్ పై పద్ధతి పరిమితి పరామితి
ప్యాకేజీ MyPackage పబ్లిక్ క్లాస్ SplitMethod {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str = '468-567-7388' స్ట్రింగ్ [] arrOfStr1 = str.split ('8', 2) System.out.println ('అవుట్పుట్ పరిమితి + ve అయినప్పుడు) System.out.println ('సబ్‌స్ట్రింగ్‌ల సంఖ్య:' + arrOfStr1.length) కోసం (int i = 0 i అవుట్పుట్:
పరిమితి ఉన్నప్పుడు అవుట్పుట్ + ve సబ్‌స్ట్రింగ్‌ల సంఖ్య: 2 str [0]: 46 str [1]: -567-7388 పరిమితి ఉన్నప్పుడు అవుట్పుట్ -ve సబ్‌స్ట్రింగ్‌ల సంఖ్య: 4 str [0]: 46 str [1]: -567 -73 str [2]: str [3]: పరిమితి 0 అయినప్పుడు అవుట్పుట్ సబ్‌స్ట్రింగ్‌ల సంఖ్య: 2 str [0]: 46 str [1]: -567-73
పై ప్రోగ్రామ్ స్ప్లిట్ () పద్ధతి ఎలా పనిచేస్తుందో చూపిస్తుంది పరిమితి పరామితి పేర్కొనబడింది. మీరు అవుట్పుట్ నుండి చూస్తున్నట్లుగా:
- పరిమితి 2 అయినప్పుడు, ఫలిత శ్రేణిలోని సబ్‌స్ట్రింగ్‌ల సంఖ్య రెండు
- పరిమితి -3 అయినప్పుడు, ఇన్పుట్ స్ట్రింగ్ 4 సబ్‌స్ట్రింగ్‌లుగా విభజించబడింది, వీటిలో వెనుకంజలో ఉన్న ఖాళీలు ఉన్నాయి
- పరిమితి 0 అయినప్పుడు, ఇన్పుట్ స్ట్రింగ్ 2 సబ్‌స్ట్రింగ్‌లుగా విభజించబడింది ఎందుకంటే వెనుకంజలో ఉన్న ఖాళీలు మినహాయించబడ్డాయి
ఇది ఈ ‘జావాలో స్ప్లిట్ మెథడ్’ వ్యాసం ముగింపుకు మనలను తీసుకువస్తుంది. నేను ఉపయోగించి తీగలను ఎలా విభజించాలో జావా యొక్క ప్రాథమిక అంశాలలో ఒకదాన్ని కవర్ చేసాను స్ప్లిట్ () పద్ధతి జావాలో.ఈ వ్యాసంలో మీతో పంచుకున్న అన్ని విషయాలతో మీరు స్పష్టంగా ఉన్నారని ఆశిస్తున్నాము.
మీరు వీలైనంత వరకు ప్రాక్టీస్ చేశారని నిర్ధారించుకోండి మరియు మీ అనుభవాన్ని తిరిగి పొందండి.
చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ ‘జావాలో స్ట్రింగ్‌కు పూర్ణాంకానికి ఎలా మార్చాలి’ అనే వ్యాఖ్యల విభాగంలో పేర్కొనండి వ్యాసం మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.