జావాలో రీజెక్స్ వైట్‌స్పేస్ ఎలా ఉపయోగించాలి

Javalo Rijeks Vait Spes Ela Upayogincali

Regex లేదా రెగ్యులర్ ఎక్స్‌ప్రెషన్ అనేది స్ట్రింగ్‌లలో అక్షరాలను శోధించడానికి ఒక నమూనాను రూపొందించడానికి మిళితం చేసే ప్రత్యేక అక్షరాల సమితి. కంప్యూటర్ ప్రోగ్రామింగ్ మరియు సాఫ్ట్‌వేర్ ఇంజనీరింగ్‌లో, రీజెక్స్ నేర్చుకోవడం ఏదైనా టెక్స్ట్‌లో సమాచారాన్ని కనుగొనడంలో చాలా సహాయకారిగా ఉంటుంది. అన్ని రకాల టెక్స్ట్ సెర్చ్, ఫార్మాటింగ్ మరియు టెక్స్ట్ రీప్లేస్‌మెంట్ ఆపరేషన్‌లను సాధారణ వ్యక్తీకరణలను ఉపయోగించి నిర్వహించవచ్చు.

ఈ ట్యుటోరియల్ జావాలో రీజెక్స్ వైట్‌స్పేస్‌ను ఉపయోగించడం గురించి మీకు మార్గనిర్దేశం చేస్తుంది.



జావాలో Regex అంటే ఏమిటి?

రెగ్యులర్ ఎక్స్‌ప్రెషన్ లేదా రెజెక్స్ ఒకే అక్షరం లేదా సంక్లిష్ట నమూనా వలె సరళంగా ఉండవచ్చు. ఇది ఒక నిర్దిష్ట క్రమంలో టెక్స్ట్ మరియు చిహ్నాల స్ట్రింగ్‌తో సృష్టించబడుతుంది. రీజెక్స్‌లోని చాలా అక్షరాలు అక్షరాలు మరియు టైపోగ్రాఫిక్ చిహ్నాలు. Regex అనేది కేస్-సెన్సిటివ్, కాబట్టి దీన్ని సృష్టించేటప్పుడు మరియు ఉపయోగిస్తున్నప్పుడు గుర్తుంచుకోండి.



జావాలో రీజెక్స్ వైట్‌స్పేస్ ఎలా ఉపయోగించాలి?

జావాకు ముందే నిర్వచించబడిన రెగ్యులర్ ఎక్స్‌ప్రెషన్ క్లాస్ లేనప్పటికీ. అయినప్పటికీ, మేము “ని దిగుమతి చేయడం ద్వారా సాధారణ వ్యక్తీకరణలను ఉపయోగించవచ్చు. java.util.regex ' గ్రంధాలయం. ఇది ' వంటి కొన్ని తరగతులను కలిగి ఉంటుంది నమూనా ”, ఇది రీజెక్స్ నమూనాను నిర్వచించడానికి ఉపయోగించబడుతుంది మరియు “ మ్యాచ్‌లు ” నమూనాతో శోధించడానికి ఉపయోగించే తరగతి.



జావాలో ఈ క్రింది విధంగా రెజెక్స్ వైట్‌స్పేస్‌ని ఉపయోగించడానికి రెండు పద్ధతులు ఉన్నాయి:

    • Pattern.matchs() పద్ధతిని ఉపయోగించడం (ముందే నిర్వచించిన రీజెక్స్ ఉపయోగించండి)
    • నమూనా మరియు సరిపోలిక తరగతిని ఉపయోగించడం (సరిపోలడానికి వినియోగదారు నిర్వచించిన రీజెక్స్‌ని సృష్టించండి)

జావాలోని వైట్‌స్పేస్ కోసం ఈ పద్ధతులు రీజెక్స్‌తో ఎలా పని చేస్తాయో చూద్దాం.

విధానం 1: జావాలో Pattern.match() పద్ధతితో ముందే నిర్వచించిన రీజెక్స్ వైట్‌స్పేస్‌ని ఉపయోగించండి

స్ట్రింగ్‌లో వైట్‌స్పేస్‌లను కనుగొనడానికి, జావాలో మూడు సాధారణ రీజెక్స్‌లు ఉన్నాయి:



    • \s : ఇది ఒకే తెల్లని స్థలాన్ని సూచిస్తుంది.
    • \s+ : ఇది బహుళ తెల్లని ఖాళీలను సూచిస్తుంది.
    • \u0020 : ఇది టెక్స్ట్‌లో వైట్‌స్పేస్‌ను కనుగొనడానికి రీజెక్స్‌గా ఉపయోగించే వైట్ స్పేస్ యొక్క యూనికోడ్.

మేము ఈ రీజెక్స్‌లను స్టాటిక్ పద్ధతిలో ఉపయోగించవచ్చు ' మ్యాచ్‌లు() ' యొక్క ' నమూనా ” తరగతి. నమూనా తరగతికి చెందినది ' java.util.regex ” ప్యాకేజీ. క్రింద Pattern.match() పద్ధతి యొక్క సింటాక్స్ ఇవ్వబడింది:

వాక్యనిర్మాణం

Pattern.matches ( '\s' , '' ) ;


పేర్కొన్న పద్ధతి రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: సాధారణ వ్యక్తీకరణ మరియు సరిపోలడానికి స్ట్రింగ్. మొదటి ఆర్గ్యుమెంట్ “\s” అనేది వైట్ స్పేస్ యొక్క రెగ్యులర్ ఎక్స్‌ప్రెషన్ లేదా రీజెక్స్ మరియు రెండవ ఆర్గ్యుమెంట్ ”” స్ట్రింగ్‌లోని ఖాళీ. ఇది బూలియన్ విలువగా ఒప్పు లేదా తప్పును అందిస్తుంది.

ఉదాహరణ 1: “\s” WhiteSpace Regexని ఉపయోగించండి

ఇక్కడ, మేము 'ని ఉపయోగిస్తాము \s Pattern.matchs() పద్ధతిలో రీజెక్స్. మేము పద్ధతిలో ఖాళీ లేని స్ట్రింగ్‌ను రెండవ ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము. ఈ పద్ధతి రీజెక్స్ మరియు స్ట్రింగ్‌ను తనిఖీ చేసి, ఆపై 'లో నిల్వ చేయబడే బూలియన్ విలువను అందిస్తుంది. మ్యాచ్ ”వేరియబుల్:

బూలియన్ మ్యాచ్ = నమూనా.మ్యాచ్‌లు ( '\s' , '' ) ;


“ని ఉపయోగించి మ్యాచ్ వేరియబుల్ విలువను ముద్రించండి System.out.println() 'పద్ధతి:

System.out.println ( 'స్పేస్ ఉంది:' + మ్యాచ్ ) ;



' ద్వారా అందించబడిన విలువ Pattern.matchs() 'పద్ధతి' తప్పుడు ” ఎందుకంటే పాస్ చేసిన స్ట్రింగ్‌లో ఖాళీ లేదు:


ఇప్పుడు మనం వైట్‌స్పేస్‌ని ఇతర రీజెక్స్‌లతో సరిపోల్చడానికి మరికొన్ని ఉదాహరణలను చూస్తాము.

ఉదాహరణ 2: “\s+” WhiteSpace Regexని ఉపయోగించండి

ఈ ఉదాహరణలో, మేము పాస్ చేస్తాము ' \s+ 'రెజెక్స్' లో మ్యాచ్‌లు() బహుళ ఖాళీలను కనుగొనే పద్ధతి:

బూలియన్ మ్యాచ్ = నమూనా.మ్యాచ్‌లు ( '\s+' , '' ) ;


పద్ధతి నుండి తిరిగి వచ్చిన ఫలితాన్ని నిల్వ చేసే మ్యాచ్ వేరియబుల్ విలువను ముద్రించండి:

System.out.println ( 'స్పేస్ ఉంది:' + మ్యాచ్ ) ;



రెండవ ఆర్గ్యుమెంట్ ఖాళీలను కలిగి ఉన్నందున, ఫలిత విలువ ''గా ప్రదర్శించబడుతుంది నిజం ”:

ఉదాహరణ 3: “\u0020” WhiteSpace Regexని ఉపయోగించండి

జావాలో యూనికోడ్ రీజెక్స్‌గా ఎలా ఉపయోగించబడుతుందో ఇక్కడ మేము మీకు చూపుతాము. పేర్కొన్న ప్రయోజనం కోసం, మేము ఉపయోగిస్తాము ' \u0020 వైట్ స్పేస్ యొక్క యూనికోడ్‌గా regex:

బూలియన్ మ్యాచ్ = నమూనా.మ్యాచ్‌లు ( '\u0020' , '' ) ;


తిరిగి వచ్చిన విలువను ప్రింట్ చేయండి:

System.out.println ( 'స్పేస్ ఉంది:' + మ్యాచ్ ) ;



Pattern.matchs() పద్ధతి ముద్రిస్తుంది “ నిజం ” వైట్ స్పేస్‌లను కలిగి ఉన్న పాస్ స్ట్రింగ్‌గా:


జావాలో రీజెక్స్‌ని ఉపయోగించడానికి ఇతర పద్ధతికి వెళ్దాం.

విధానం 2: సరళి మరియు సరిపోలిక తరగతితో వినియోగదారు నిర్వచించిన రీజెక్స్ వైట్‌స్పేస్‌ని ఉపయోగించండి

ది ' నమూనా 'తరగతి ఒక నమూనాను నిర్వచించడానికి లేదా సృష్టించడానికి ఉపయోగించబడుతుంది, అయితే ' మ్యాచ్‌లు ” క్లాస్ ఇవ్వబడిన నమూనా ప్రకారం శోధించడానికి ఉపయోగించబడుతుంది. రీజెక్స్ కోసం నమూనాను '' సహాయంతో సృష్టించవచ్చు కంపైల్() 'నమూనా తరగతి యొక్క పద్ధతి. ఇది ఒక పరామితిని మాత్రమే తీసుకుంటుంది, మీరు ఏదైనా ప్రయోజనం కోసం కంపైల్ చేయాలనుకుంటున్న నమూనా.

వాక్యనిర్మాణం

Pattern.compile ( ' \t \p{Zs}' ) ;


ది మ్యాచ్‌లు 'ని ఉపయోగించడం ద్వారా తరగతి నమూనాతో సరిపోతుంది మ్యాచ్‌లు() ” పద్ధతి. ఇది పడుతుంది ' స్ట్రింగ్ ” నమూనాగా.

వాక్యనిర్మాణం

patternVariable.matcher ( స్ట్రింగ్ ) ;


మేము పైన చర్చించిన వైట్‌స్పేస్‌ల కోసం కొన్ని ముందే నిర్వచించబడిన రీజెక్స్ ఉన్నాయి, మిగిలినవి క్రింద ఇవ్వబడ్డాయి:

    • \\t\\p{Zs}
    • \\p{Zs}

ఇప్పుడు, కొన్ని ఉదాహరణలను పరిశీలిద్దాం.

ఉదాహరణ 1: “\\t\\p{Zs}” WhiteSpace Regexని ఉపయోగించండి

ఈ ఉదాహరణలో, మేము వాటిని లెక్కించడం ద్వారా వైట్‌స్పేస్‌ల సంఖ్యను కనుగొంటాము. మొదట, మేము స్ట్రింగ్‌ను సృష్టిస్తాము ' లు ” మరియు దానిని కన్సోల్‌లో ప్రింట్ చేయండి:

స్ట్రింగ్ s = 'WelcometoLinuxHint' ;
System.out.println ( లు ) ;


తరువాత, మేము ఒక నమూనాను నిర్వచిస్తాము ' \\t\\p{Zs} 'ఇది జావాలో వైట్‌స్పేస్ రీజెక్స్‌గా పనిచేస్తుంది మరియు దీనికి సమానం' \s ”. ఇచ్చిన నమూనాను కంపైల్ చేసిన తర్వాత, వేరియబుల్ ' regexPattern ” ఫలిత విలువను కలిగి ఉంటుంది:

నమూనా regexPattern = Pattern.compile ( '\ \t \\p{Zs}' ) ;


కాల్ చేయండి' మ్యాచ్‌లు() 'పద్ధతి మరియు పాస్' లు ” స్ట్రింగ్:

మ్యాచర్ stringSpaces = regexPattern.matcher ( లు ) ;


పూర్ణాంక రకం వేరియబుల్‌ను సృష్టించండి ' లెక్కించండి 'మరియు దానిని విలువతో ప్రారంభించండి' 0 ”:

int కౌంట్ = 0 ;


'ని ఉపయోగించడం ద్వారా స్ట్రింగ్‌లో ఉన్న వైట్‌స్పేస్‌ల సంఖ్యను లెక్కించండి అయితే ” లూప్. లూప్ స్ట్రింగ్‌ను దాటుతుంది మరియు ఏదైనా ఖాళీని ఎదుర్కొంటే కౌంట్ వేరియబుల్ విలువను పెంచుతుంది:

అయితే ( stringSpaces.find ( ) ) {
కౌంట్++;
}


చివరగా, స్ట్రింగ్‌లో ఎన్ని ఖాళీలు ఉన్నాయో చూపించడానికి గణన విలువను ప్రింట్ చేయండి:

System.out.println ( 'స్ట్రింగ్ కలిగి ఉంది' +కౌంట్+ 'ఖాళీలు' ) ;


అవుట్‌పుట్



ఉదాహరణ 2: “\p{Zs}” WhiteSpace Regexని ఉపయోగించండి

ఇప్పుడు, మేము మరొక నమూనాను ఉపయోగించడం ద్వారా స్ట్రింగ్‌లోని వైట్‌స్పేస్‌లను కనుగొంటాము ' \p{Zs} ”. ఈ నమూనా '' వలె పనిచేస్తుంది \s 'మరియు' \s+ 'రెజెక్స్:

నమూనా regexPattern = Pattern.compile ( '\\p{Zs}' ) ;


ఇప్పుడు మనం '' అని పిలుస్తాము మ్యాచ్‌లు() 'పద్ధతి మరియు పాస్' లు ” వాదన వలె స్ట్రింగ్:

మ్యాచర్ stringSpaces = regexPattern.matcher ( లు ) ;


పై ఉదాహరణలో వలె, మేము కూడా ఉపయోగిస్తాము ' అయితే స్ట్రింగ్‌లోని ఖాళీలను లెక్కించడానికి మరియు వాటిని ప్రింట్ చేయడానికి లూప్ చేయండి:



ఇచ్చిన అవుట్‌పుట్ మన స్ట్రింగ్ ' అని సూచిస్తుంది Linux సూచనకు స్వాగతం ” మూడు ఖాళీలను కలిగి ఉంది:



జావాలో రీజెక్స్ వైట్‌స్పేస్‌ని ఉపయోగించడానికి మీకు సహాయపడే అన్ని సులభమైన పద్ధతులను మేము కంపైల్ చేస్తాము.

ముగింపు

వైట్‌స్పేస్ కోసం అనేక సాధారణ వ్యక్తీకరణలు ఉన్నాయి, అవి “ \s ',' \s+ ',' \u0020 ',' \\t\\p{Zs} ', మరియు' \\p{Zs} ”. ఈ రీజెక్స్‌లు ప్యాటర్న్ క్లాస్‌లోని మ్యాచ్‌లు() పద్ధతిలో లేదా ప్యాటర్న్ క్లాస్‌తో నమూనాను నిర్వచించడం ద్వారా మరియు మ్యాచర్ క్లాస్‌ని ఉపయోగించి సరిపోల్చడం ద్వారా ఉపయోగించబడతాయి. అత్యంత సాధారణంగా ఉపయోగించే రీజెక్స్ వైట్‌స్పేస్ \s మరియు \s+. ఈ ట్యుటోరియల్‌లో, మేము జావాలో రీజెక్స్ వైట్‌స్పేస్‌ని ఉపయోగించడానికి అన్ని పద్ధతులను కవర్ చేసాము.