డేటా వెలికితీత లేదా ధ్రువీకరణ ప్రతి ప్రోగ్రామింగ్ భాషలో ఒక ముఖ్యమైన అంశం. సాధారణ ధృవీకరణలను ఉపయోగించడం ద్వారా డేటా ధ్రువీకరణకు అత్యంత ప్రాచుర్యం పొందిన మార్గాలలో ఒకటి. వీటిని ఉపయోగిస్తుందిఅక్షరాల నమూనాను వివరించడానికి సాధారణ వ్యక్తీకరణలు. ఈ వ్యాసం జావా రెగెక్స్ కింది క్రమంలో వ్యక్తీకరణలను ఉపయోగించే వివిధ పద్ధతులను జాబితా చేస్తుంది:
- రెగ్యులర్ వ్యక్తీకరణలు అంటే ఏమిటి?
- జావా రీజెక్స్ అంటే ఏమిటి?
- మ్యాచర్ క్లాస్
- సరళి తరగతి
- రెగెక్స్ అక్షర తరగతి
- రెగెక్స్ క్వాంటిఫైయర్స్
- రెగెక్స్ మెటాచ్రాక్టర్స్
ప్రారంభిద్దాం!
జావాలో సంఖ్యను రివర్స్ చేయండి
రెగ్యులర్ వ్యక్తీకరణలు అంటే ఏమిటి?
TO రెగ్యులర్ వ్యక్తీకరణ శోధన నమూనాను నిర్మించే అక్షరాల క్రమం. మీరు టెక్స్ట్‌లో డేటా కోసం శోధిస్తున్నప్పుడు, మీరు వెతుకుతున్నదాన్ని వివరించడానికి ఈ శోధన నమూనాను ఉపయోగించవచ్చు.
సాధారణ వ్యక్తీకరణ a ఒకే అక్షరం లేదా మరింత క్లిష్టమైన నమూనా. ఇది ఏ రకమైన టెక్స్ట్ సెర్చ్ మరియు టెక్స్ట్ రీప్లేస్ ఆపరేషన్లకు ఉపయోగించవచ్చు. రెగెక్స్ నమూనా వంటి సాధారణ అక్షరాలను కలిగి ఉంటుంది / abc / , లేదా వంటి సాధారణ మరియు ప్రత్యేక అక్షరాల కలయిక / ab * c / లేదా /example(d+).d*/ .
జావా రీజెక్స్ అంటే ఏమిటి?
ది జావా రెగెక్స్ ఉపయోగించిన API శోధించడం లేదా మార్చడం కోసం ఒక నమూనాను నిర్వచించండి . పాస్వర్డ్ మరియు ఇమెయిల్ ధ్రువీకరణ వంటి స్ట్రింగ్స్ యొక్క అడ్డంకిని నిర్వచించడానికి ఇది విస్తృతంగా ఉపయోగించబడుతుంది.
జావా రీగెక్స్‌ను ఉపయోగించటానికి వివిధ పద్ధతులు ఉన్నాయి. కాబట్టి ముందుకు సాగండి మరియు విభిన్న వ్యక్తీకరణలను చూద్దాం.
మ్యాచర్ క్లాస్
అక్షర శ్రేణిలో మ్యాచ్ ఆపరేషన్లు చేయడానికి ఈ తరగతి ఉపయోగించబడుతుంది. దిగువ పట్టిక మాచర్ క్లాస్ యొక్క వివిధ పద్ధతులను సూచిస్తుంది.
| విధానం | వివరణ |
|---|---|
| బూలియన్ మ్యాచ్‌లు () | ఇచ్చిన రెగ్యులర్ వ్యక్తీకరణ నమూనాతో సరిపోతుందో లేదో పరీక్షిస్తుంది |
| బూలియన్ కనుగొను () | నమూనాతో సరిపోయే తదుపరి వ్యక్తీకరణను కనుగొనడానికి ఉపయోగిస్తారు |
| బూలియన్ కనుగొను (పూర్ణాంక ప్రారంభం) | ఇచ్చిన ప్రారంభ సంఖ్య నుండి నమూనాతో సరిపోయే తదుపరి వ్యక్తీకరణను శోధిస్తుంది |
| స్ట్రింగ్ సమూహం () | సరిపోలిన తదుపరిదాన్ని తిరిగి ఇవ్వడానికి ఉపయోగిస్తారు |
| పూర్ణాంక ప్రారంభం () | సరిపోలిన తదుపరి ప్రారంభ సూచికను చూపుతుంది |
| పూర్ణాంక ముగింపు () | సరిపోలిన తరువాతి ముగింపు సూచికను చూపుతుంది |
| int groupCount () | సరిపోలిన తదుపరి మొత్తం సంఖ్యను అందిస్తుంది |
సరళి తరగతి
సరళి తరగతి అనేది రెగ్యులర్ వ్యక్తీకరణ యొక్క సంకలనం చేయబడిన సంస్కరణ, ఇది రీజెక్స్ ఇంజిన్ యొక్క నమూనాను నిర్వచించడానికి ఉపయోగించబడుతుంది.
| విధానం | వివరణ |
|---|---|
| స్టాటిక్ సరళి కంపైల్ (స్ట్రింగ్ రీజెక్స్) | ఇది ఇచ్చిన రిజెక్స్‌ను సంకలనం చేస్తుంది మరియు సరళి యొక్క ఉదాహరణను అందిస్తుంది |
| సరిపోలిక మ్యాచ్‌లు (చార్‌సక్వెన్స్ ఇన్పుట్) | ఇచ్చిన ఇన్‌పుట్‌తో నమూనాతో సరిపోయే మ్యాచర్‌ను సృష్టించడానికి ఇది ఉపయోగించబడుతుంది |
| స్టాటిక్ బూలియన్ మ్యాచ్‌లు (స్ట్రింగ్ రీజెక్స్, చార్‌సక్వెన్స్ ఇన్పుట్) | ఇది కంపైల్ మరియు మ్యాచర్ పద్ధతుల కలయికగా పనిచేస్తుంది. ఇది రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ను కంపైల్ చేస్తుంది మరియు ఇచ్చిన ఇన్‌పుట్‌తో నమూనాతో సరిపోతుంది |
| స్ట్రింగ్ [] స్ప్లిట్ (చార్‌సక్వెన్స్ ఇన్పుట్) | ఇచ్చిన నమూనా యొక్క మ్యాచ్‌ల చుట్టూ ఇచ్చిన ఇన్పుట్ స్ట్రింగ్‌ను విభజించడానికి ఉపయోగిస్తారు |
| స్ట్రింగ్ నమూనా () | రీజెక్స్ నమూనాను తిరిగి ఇవ్వడానికి సహాయపడుతుంది |
సాధారణ వ్యక్తీకరణను ఎలా వ్రాయాలో అర్థం చేసుకోవడానికి ఇప్పుడు ఒక చిన్న ఉదాహరణ తీసుకుందాం.
java.util.regex ను దిగుమతి చేయండి. .println ('స్ట్రింగ్ ఇచ్చిన రీగెక్స్‌తో సరిపోతుంది - + matcher.matches ())}}ఈ సందర్భంలో, అంతర్గతంగా ఇది సరళి మరియు సరిపోలికను ఉపయోగిస్తుంది ప్రాసెసింగ్ చేయడానికి రెగెక్స్ తరగతులు కానీ స్పష్టంగా,ఇది కోడ్ పంక్తులను తగ్గిస్తుంది. సరళి తరగతి కూడా మ్యాచ్ పద్ధతిని కలిగి ఉంది, ఇది రీగెక్స్ మరియు ఇన్పుట్ స్ట్రింగ్‌ను వాదనగా తీసుకుంటుంది మరియు వాటిని సరిపోల్చిన తర్వాత బూలియన్ ఫలితాన్ని ఇస్తుంది. కాబట్టి ఇన్పుట్ సరిపోలడానికి కోడ్ బాగా పనిచేస్తుంది జావాలో రెగ్యులర్ వ్యక్తీకరణతో. అందువల్ల క్రింద చూపిన విధంగా అవుట్పుట్ నిజం అవుతుంది.
అవుట్పుట్:
నిజం
తేదీకి స్ట్రింగ్‌ను ఎలా మార్చాలి
ఇప్పుడు జావా రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ యొక్క మరికొన్ని వర్గాలను చూద్దాం.
రెగెక్స్ అక్షర తరగతి
క్రింద పట్టిక విభిన్న అక్షర తరగతి కలయికను సూచిస్తుంది.
| అక్షర తరగతి | వివరణ |
|---|---|
| [abc] | a, b, లేదా c (సాధారణ తరగతి) |
| [^ abc] | A, b, లేదా c (తిరస్కరణ) మినహా ఏదైనా అక్షరం |
| [a-zA-Z] | a ద్వారా z లేదా A ద్వారా Z, కలుపుకొని (పరిధి) |
| [a-d [m-p]] | a ద్వారా d, లేదా m ద్వారా p: [a-dm-p] (యూనియన్) |
| [a-z && [డెఫ్]] | d, e, లేదా f (ఖండన) |
| [a-z && [^ bc]] | a మరియు z ద్వారా, b మరియు c మినహా: [ad-z] (వ్యవకలనం) |
| [a-z && [^ m-p]] | a ద్వారా z, మరియు p ద్వారా m కాదు: [a-lq-z] (వ్యవకలనం) |
ఉదాహరణ:
java.util.regex ను దిగుమతి చేయండి. 'wbcd')) // true (x లేదా y లేదా z మధ్య) System.out.println (Pattern.matches ('[xyz]', 'x')) // తప్పుడు (x మరియు y ఒకటి కంటే ఎక్కువసార్లు వస్తుంది) సిస్టమ్ .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}రెగెక్స్ క్వాంటిఫైయర్స్
క్వాంటిఫైయర్లు ఒక పాత్ర యొక్క సంఘటనల సంఖ్యను తెలుపుతాయి. క్రింద పట్టిక వివిధ క్వాంటిఫైయర్లను సూచిస్తుంది.
| రెగెక్స్ | వివరణ |
|---|---|
| X? | X ఒకసారి సంభవిస్తుంది లేదా కాదు |
| X + | X ఒకటి లేదా అంతకంటే ఎక్కువ సార్లు సంభవిస్తుంది |
| X * | X సున్నా లేదా అంతకంటే ఎక్కువ సార్లు సంభవిస్తుంది |
| X {n} | X సంభవిస్తుంది n సార్లు మాత్రమే |
| X {n,} | X n లేదా అంతకంటే ఎక్కువ సార్లు సంభవిస్తుంది |
| X మరియు Z} | X కనీసం y సార్లు సంభవిస్తుంది, కానీ z సార్లు కంటే తక్కువ |
ఉదాహరణ:
java.util.regex ను దిగుమతి చేయండి. * పబ్లిక్ క్లాస్ ఉదాహరణ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {System.out.println ('? క్వాంటిఫైయర్ ....') // (a లేదా y లేదా z ఒక సారి వస్తుంది) System.out.println (Pattern.matches ('[ayz]?', 'A')) // అవుట్పుట్: నిజమైన System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay మరియు z ఒకటి కంటే ఎక్కువ సార్లు వస్తుంది) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // అవుట్పుట్: తప్పుడు // (ఒకటి కంటే ఎక్కువ సార్లు వస్తుంది) సిస్టమ్. out.println (Pattern.matches ('[ayz]?', 'amnta')) // అవుట్పుట్: తప్పుడు // (a లేదా y లేదా z ఒక సారి రావాలి) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // అవుట్పుట్: తప్పుడు System.out.println (' + క్వాంటిఫైయర్ .... ') // (a లేదా y లేదా z ఒకసారి లేదా అంతకంటే ఎక్కువ సార్లు) System.out.println (సరళి . సరిపోలికలు ('[ayz] +', 'a')) // అవుట్పుట్: true // (a ఒకటి కంటే ఎక్కువ సార్లు వస్తుంది) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a లేదా y లేదా z ఒకటి కంటే ఎక్కువసార్లు వస్తుంది) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // అవుట్పుట్: true // (z మరియు t సరిపోయే నమూనా కాదు) System.out.println (పాట్ tern.matches ('[ayz] +', 'aammta')) // అవుట్పుట్: తప్పుడు System.out.println ('* క్వాంటిఫైయర్ ....') // (a లేదా y లేదా z సున్నా లేదా అంతకంటే ఎక్కువ సార్లు రావచ్చు ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // అవుట్పుట్: true}}సాధారణంగా, ఇది మ్యాచింగ్ క్వాంటిఫైయర్ కోసం శోధిస్తుంది మరియు శోధన ఫలితంతో సరిపోతుంది.
పనిముట్లు మరియు విస్తరణల మధ్య జావా వ్యత్యాసం
రెగెక్స్ మెటాచ్రాక్టర్స్
రెగ్యులర్ ఎక్స్‌ప్రెషన్ మెటాచ్రాక్టర్స్ షార్ట్‌కోడ్‌లుగా పనిచేస్తాయి. వివిధ రకాల మెటా కారెక్టర్లను అర్థం చేసుకోవడానికి ఈ క్రింది పట్టికను చూద్దాం.
| రెగెక్స్ | వివరణ |
|---|---|
| . | ఇది ఏదైనా అక్షరం కావచ్చు (టెర్మినేటర్‌తో సరిపోలవచ్చు లేదా సరిపోకపోవచ్చు) |
| d | ఏదైనా అంకెలను సూచిస్తుంది, [0-9] |
| డి | [^ 0-9] కు చిన్నది కాని అంకెలను సూచిస్తుంది. |
| s | [Tnx0Bfr] కు చిన్న వైట్‌స్పేస్ అక్షరాన్ని సూచిస్తుంది |
| ఎస్ | ఇది వైట్‌స్పేస్ కాని పాత్ర కావచ్చు, [^ s] కు చిన్నది |
| లో | ఇది [a-zA-Z_0-9] కు చిన్న పద అక్షరం కావచ్చు |
| IN | [^ W] కు చిన్న ఏదైనా పదేతర అక్షరాన్ని సూచిస్తుంది |
| బి | పద సరిహద్దును సూచిస్తుంది |
| బి | ఇది పదం కాని సరిహద్దు |
ఉదాహరణ:
java.util.regex ను దిగుమతి చేయండి. System.out.println (Pattern.matches ('d', 'abc')) // అవుట్పుట్: తప్పుడు // (అంకె మరియు ఒకసారి వస్తుంది) System.out.println (Pattern.matches ('d', '1') ) // అవుట్పుట్: ట్రూ // (అంకెల కానీ ఒకటి కంటే ఎక్కువసార్లు వస్తుంది) System.out.println (Pattern.matches ('d', '4443')) // అవుట్పుట్: తప్పుడు // (అంకె మరియు చార్) System.out .println (Pattern.matches ('d', '323abc')) // అవుట్పుట్: తప్పుడు // D అంటే అంకెలు కాని System.out.println ('మెటాచ్రాక్టర్స్ D ....') // (అంకెలు కాని కానీ ఒకటి కంటే ఎక్కువసార్లు వస్తుంది) System.out.println (Pattern.matches ('D', 'abc')) // అవుట్పుట్: తప్పుడు // దీని అంకెల వ్యవస్థ. out.println (Pattern.matches ('D', '1 ')) // అవుట్పుట్: తప్పుడు System.out.println (Pattern.matches (' D ',' 4443 ')) // అవుట్పుట్: తప్పుడు // (అంకె మరియు చార్) System.out.println (Pattern.matches (' D ',' 323abc ')) // అవుట్పుట్: తప్పుడు // (అంకెలు కానిది మరియు ఒకసారి వస్తుంది) System.out.println (Pattern.matches (' D ',' m ')) // అవుట్పుట్: నిజమైన System.out .pr intln ('క్వాంటిఫైయర్‌తో మెటాచ్రాక్టర్స్ డి ....') // (అంకెలు కానిది మరియు 0 లేదా అంతకంటే ఎక్కువ సార్లు రావచ్చు) System.out.println (Pattern.matches ('D *', 'abc')) // అవుట్పుట్ : నిజమైన}}పైన పేర్కొన్న పరిస్థితుల ఆధారంగా, ఇది అవుట్పుట్ను ప్రదర్శిస్తుంది. ఇది ఎలా పనిచేస్తుంది. కాబట్టి, ఇది వివిధ రకాల గురించి రెగెక్స్. దీనితో, మేము ఈ వ్యాసం చివరికి వస్తాము. నేనుమీరు సమాచారంగా కనుగొన్నారని ఆశిస్తున్నాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, మీరు మా తనిఖీ చేయవచ్చు అలాగే.
చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావా రీగెక్స్” వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.