தரவு பிரித்தெடுத்தல் அல்லது சரிபார்ப்பு என்பது ஒவ்வொரு நிரலாக்க மொழியின் முக்கிய அம்சமாகும். வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துவதன் மூலம் தரவு சரிபார்ப்பிற்கான மிகவும் பிரபலமான வழிகளில் ஒன்று. இவற்றைப் பயன்படுத்துகிறதுஎழுத்துக்களின் வடிவத்தை விவரிக்க வழக்கமான வெளிப்பாடுகள். இந்த கட்டுரை ஜாவா ரீஜெக்ஸ் பின்வரும் வரிசையில் வெளிப்பாடுகளைப் பயன்படுத்துவதற்கான பல்வேறு முறைகளை பட்டியலிடும்:
- வழக்கமான வெளிப்பாடுகள் என்றால் என்ன?
- ஜாவா ரீஜெக்ஸ் என்றால் என்ன?
- மேட்சர் வகுப்பு
- பேட்டர்ன் வகுப்பு
- ரீஜெக்ஸ் எழுத்து வகுப்பு
- ரீஜெக்ஸ் அளவு
- ரீஜெக்ஸ் மெட்டாராக்டர்கள்
தொடங்குவோம்!
வழக்கமான வெளிப்பாடுகள் என்றால் என்ன?
TO வழக்கமான வெளிப்பாடு ஒரு தேடல் வடிவத்தை உருவாக்கும் எழுத்துகளின் வரிசை. நீங்கள் ஒரு உரையில் தரவைத் தேடும்போது, நீங்கள் தேடுவதை விவரிக்க இந்த தேடல் முறையைப் பயன்படுத்தலாம்.
ஒரு வழக்கமான வெளிப்பாடு a ஒற்றை எழுத்து அல்லது மிகவும் சிக்கலான முறை. இது எந்த வகை உரை தேடலுக்கும் உரை மாற்று செயல்பாடுகளுக்கும் பயன்படுத்தப்படலாம். ஒரு ரீஜெக்ஸ் முறை போன்ற எளிய எழுத்துக்கள் உள்ளன / abc / , அல்லது போன்ற எளிய மற்றும் சிறப்பு எழுத்துக்களின் கலவையாகும் / ab * c / அல்லது /example(d+).d*/ .
ஜாவா ரீஜெக்ஸ் என்றால் என்ன?
தி ஜாவா ரீஜெக்ஸ் ஒரு API ஆகும் தேடுவதற்கோ அல்லது கையாளுவதற்கோ ஒரு வடிவத்தை வரையறுக்கவும் . கடவுச்சொல் மற்றும் மின்னஞ்சல் சரிபார்ப்பு போன்ற சரங்களின் தடையை வரையறுக்க இது பரவலாகப் பயன்படுத்தப்படுகிறது.
ஜாவா ரீஜெக்ஸைப் பயன்படுத்துவதற்கு வெவ்வேறு முறைகள் உள்ளன. எனவே முன்னேறி வெவ்வேறு வெளிப்பாடுகளைப் பார்ப்போம்.
மேட்சர் வகுப்பு
எழுத்துக்குறி வரிசையில் போட்டி செயல்பாடுகளைச் செய்ய இந்த வகுப்பு பயன்படுத்தப்படுகிறது. அட்டவணை கீழே மேட்சர் வகுப்பின் பல்வேறு முறைகளைக் குறிக்கிறது.
ஜாவாவில் உள்ள பொருட்களின் வரிசை
| முறை | விளக்கம் |
|---|---|
| பூலியன் போட்டிகள் () | கொடுக்கப்பட்ட வழக்கமான வெளிப்பாடு முறைக்கு பொருந்துமா என்பதை சோதிக்கிறது |
| பூலியன் கண்டுபிடி () | வடிவத்துடன் பொருந்தக்கூடிய அடுத்த வெளிப்பாட்டைக் கண்டுபிடிக்கப் பயன்படுகிறது |
| பூலியன் கண்டுபிடிப்பு (முழு தொடக்க) | கொடுக்கப்பட்ட தொடக்க எண்ணிலிருந்து வடிவத்துடன் பொருந்தக்கூடிய அடுத்த வெளிப்பாட்டைத் தேடுகிறது |
| சரம் குழு () | பொருந்திய அடுத்தடுத்து திரும்பப் பயன்படுகிறது |
| முழு தொடக்க () | பொருந்திய அடுத்தடுத்த தொடக்கக் குறியீட்டை வழங்குகிறது |
| int end () | பொருந்திய அடுத்தடுத்த முடிவுக் குறியீட்டை வழங்குகிறது |
| int groupCount () | பொருந்திய அடுத்தடுத்த மொத்த எண்ணிக்கையை வழங்குகிறது |
பேட்டர்ன் வகுப்பு
பேட்டர்ன் கிளாஸ் என்பது வழக்கமான வெளிப்பாட்டின் தொகுக்கப்பட்ட பதிப்பாகும், இது ரீஜெக்ஸ் இயந்திரத்திற்கான வடிவத்தை வரையறுக்கப் பயன்படுகிறது.
| முறை | விளக்கம் |
|---|---|
| நிலையான பேட்டர்ன் தொகுத்தல் (சரம் ரீஜெக்ஸ்) | இது கொடுக்கப்பட்ட ரீஜெக்ஸை தொகுத்து, வடிவத்தின் உதாரணத்தை வழங்குகிறது |
| போட்டிகளுடன் பொருந்துகிறது (CharSequence உள்ளீடு) | கொடுக்கப்பட்ட உள்ளீட்டை வடிவத்துடன் பொருந்தக்கூடிய ஒரு மேட்சரை உருவாக்க இது பயன்படுகிறது |
| நிலையான பூலியன் பொருத்தங்கள் (சரம் ரீஜெக்ஸ், சார்செக்வென்ஸ் உள்ளீடு) | இது தொகுத்தல் மற்றும் மேட்சர் முறைகளின் கலவையாக செயல்படுகிறது. இது வழக்கமான வெளிப்பாட்டை தொகுத்து, கொடுக்கப்பட்ட உள்ளீட்டை வடிவத்துடன் பொருத்துகிறது |
| சரம் [] பிளவு (CharSequence உள்ளீடு) | கொடுக்கப்பட்ட உள்ளீட்டைப் பிரிக்கப் பயன்படுகிறது |
| சரம் முறை () | ரீஜெக்ஸ் வடிவத்தைத் தர உதவுகிறது |
வழக்கமான வெளிப்பாட்டை எவ்வாறு எழுதுவது என்பதைப் புரிந்துகொள்ள இப்போது ஒரு சிறிய உதாரணத்தை எடுத்துக் கொள்வோம்.
இறக்குமதி 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 && [def]] | d, e, அல்லது f (குறுக்குவெட்டு) |
| [a-z && [^ bc]] | a மற்றும் z வழியாக, b மற்றும் c ஐத் தவிர: [ad-z] (கழித்தல்) |
| [a-z && [^ m-p]] | a வழியாக z, மற்றும் m வழியாக p அல்ல: [a-lq-z] (கழித்தல்) |
உதாரணமாக:
java.util.regex ஐ இறக்குமதி செய்க. 'wbcd')) // உண்மை (x அல்லது y அல்லது z மத்தியில்) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x மற்றும் y ஒன்றுக்கு மேற்பட்ட முறை வருகிறது) கணினி .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}ரீஜெக்ஸ் அளவு
அளவுகோல்கள் ஒரு எழுத்தின் நிகழ்வுகளின் எண்ணிக்கையைக் குறிப்பிடுகின்றன. கீழே உள்ள அட்டவணை பல்வேறு அளவுகோல்களைக் குறிக்கிறது.
| ரீஜெக்ஸ் | விளக்கம் |
|---|---|
| எக்ஸ்? | எக்ஸ் ஒரு முறை ஏற்படுகிறது அல்லது இல்லை |
| எக்ஸ் + | எக்ஸ் ஒன்று அல்லது அதற்கு மேற்பட்ட முறை நிகழ்கிறது |
| எக்ஸ் * | எக்ஸ் பூஜ்ஜியம் அல்லது அதற்கு மேற்பட்ட முறை நிகழ்கிறது |
| எக்ஸ் {n} | எக்ஸ் n முறை மட்டுமே நிகழ்கிறது |
| எக்ஸ் {n,} | எக்ஸ் n அல்லது அதற்கு மேற்பட்ட முறை நிகழ்கிறது |
| எக்ஸ் மற்றும் இசட்} | எக்ஸ் குறைந்தது y முறை ஆனால் z நேரங்களுக்கும் குறைவாக நிகழ்கிறது |
உதாரணமாக:
இறக்குமதி java.util.regex. * பொது வகுப்பு எடுத்துக்காட்டு {பொது நிலையான வெற்றிட மெயின் (சரம் ஆர்க்ஸ் []) {System.out.println ('? குவாண்டிஃபையர் ....') // (a அல்லது y அல்லது z ஒரு முறை வருகிறது) System.out.println (Pattern.matches ('[ayz]?', 'A')) // வெளியீடு: true 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 (வடிவம் .matches ('[ayz] +', 'a')) // வெளியீடு: உண்மை // (ஒரு முறைக்கு மேல் வருகிறது) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a அல்லது y அல்லது z ஒன்றுக்கு மேற்பட்ட முறை வருகிறது) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // வெளியீடு: உண்மை // (z மற்றும் t பொருந்தக்கூடிய முறை அல்ல) System.out.println (பேட் tern.matches ('[ayz] +', 'aammta')) // வெளியீடு: தவறான System.out.println ('* குவாண்டிஃபையர் ....') // (a அல்லது y அல்லது z பூஜ்ஜியம் அல்லது அதற்கு மேற்பட்ட முறை வரக்கூடும் ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // வெளியீடு: உண்மை}}அடிப்படையில், இது பொருந்தக்கூடிய அளவுகோலைத் தேடி, தேடல் முடிவுடன் பொருந்துகிறது.
ரீஜெக்ஸ் மெட்டாராக்டர்கள்
வழக்கமான வெளிப்பாடு மெட்டாராக்டர்கள் ஷார்ட்கோட்களாக செயல்படுகின்றன. பல்வேறு வகையான மெட்டா கராக்டர்களைப் புரிந்துகொள்ள கீழேயுள்ள அட்டவணையைப் பார்ப்போம்.
| ரீஜெக்ஸ் | விளக்கம் |
|---|---|
| . | இது எந்த எழுத்தும் இருக்கலாம் (டெர்மினேட்டருடன் பொருந்தலாம் அல்லது பொருந்தாது) |
| d | [0-9] க்கு குறைவான எந்த இலக்கங்களையும் குறிக்கிறது |
| டி | [^ 0-9] க்கு குறுகியதாக இருக்கும் எந்த இலக்கத்தையும் குறிக்கிறது |
| கள் | [Tnx0Bfr] க்கு சுருக்கமான எந்த இடைவெளி எழுத்தையும் குறிக்கிறது |
| எஸ் | இது ஒரு இடைவெளியில்லாத பாத்திரமாக இருக்கலாம், இது [^ s] |
| இல் | இது [a-zA-Z_0-9] க்குச் சுருக்கமான சொல் எழுத்தாக இருக்கலாம் |
| IN | [^ W] க்குச் சுருக்கமான எந்த சொல் அல்லாத எழுத்தையும் குறிக்கிறது |
| b | ஒரு சொல் எல்லையை குறிக்கிறது |
| பி | இது ஒரு சொல் அல்லாத எல்லை |
உதாரணமாக:
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 ('மெட்டாராக்டர்கள் டி ....') // (இலக்கமற்றது ஆனால் ஒன்றுக்கு மேற்பட்ட முறை வருகிறது) 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 ')) // வெளியீடு: true System.out .pr intln ('அளவீட்டுடன் மெட்டாராக்டர்கள் டி ....') // (இலக்கமற்றது மற்றும் 0 அல்லது அதற்கு மேற்பட்ட முறை வரக்கூடும்) System.out.println (Pattern.matches ('D *', 'abc')) // வெளியீடு : உண்மை}}மேலே குறிப்பிட்ட நிபந்தனைகளின் அடிப்படையில், இது வெளியீட்டைக் காண்பிக்கும். அது எவ்வாறு செயல்படுகிறது. எனவே, அது பல்வேறு வகைகளைப் பற்றியது ரீஜெக்ஸ். இதன் மூலம், இந்த கட்டுரையின் முடிவுக்கு வருகிறோம். நான்நீங்கள் அதை தகவலறிந்ததாகக் கண்டீர்கள் என்று நம்புகிறேன். நீங்கள் மேலும் அறிய விரும்பினால், நீங்கள் எங்களைப் பார்க்கலாம் அத்துடன்.
பாருங்கள் உலகெங்கிலும் பரவியுள்ள 250,000 க்கும் மேற்பட்ட திருப்தியான கற்றவர்களின் வலைப்பின்னலுடன் நம்பகமான ஆன்லைன் கற்றல் நிறுவனமான எடுரேகாவால். உங்கள் பயணத்தின் ஒவ்வொரு அடியிலும் உங்களுக்கு உதவ நாங்கள் இங்கு வந்துள்ளோம், இந்த ஜாவா நேர்காணல் கேள்விகளைத் தவிர்த்து, ஜாவா டெவலப்பராக விரும்பும் மாணவர்கள் மற்றும் நிபுணர்களுக்காக வடிவமைக்கப்பட்ட ஒரு பாடத்திட்டத்தை நாங்கள் கொண்டு வருகிறோம்.
ஹடூப் டெவலப்பர் பாத்திரங்கள் மற்றும் பொறுப்புகள்
எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து இந்த “ஜாவா ரீஜெக்ஸ்” கட்டுரையின் கருத்துகள் பிரிவில் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.