ஜாவாவில் ரீஜெக்ஸ் வைட்ஸ்பேஸை எவ்வாறு பயன்படுத்துவது

Javavil Rijeks Vaitspesai Evvaru Payanpatuttuvatu



Regex அல்லது Regular Expression என்பது சிறப்பு எழுத்துகளின் தொகுப்பாகும், அவை சரங்களில் உள்ள எழுத்துக்களைத் தேட ஒரு வடிவத்தை உருவாக்குகின்றன. கம்ப்யூட்டர் புரோகிராமிங் மற்றும் சாஃப்ட்வேர் இன்ஜினியரிங்கில், ரீஜெக்ஸைக் கற்றுக்கொள்வது எந்தவொரு உரையிலும் உள்ள தகவலைக் கண்டறிய மிகவும் உதவியாக இருக்கும். அனைத்து வகையான உரை தேடல், வடிவமைப்பு மற்றும் உரை மாற்று செயல்பாடுகள் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தி மேற்கொள்ளப்படலாம்.

இந்த டுடோரியல் ஜாவாவில் ரீஜெக்ஸ் இடைவெளியைப் பயன்படுத்துவது பற்றி உங்களுக்கு வழிகாட்டும்.







ஜாவாவில் ரெஜெக்ஸ் என்றால் என்ன?

ஒரு வழக்கமான வெளிப்பாடு அல்லது ரீஜெக்ஸ் என்பது ஒற்றை எழுத்து அல்லது சிக்கலான வடிவத்தைப் போல எளிமையாக இருக்கலாம். இது ஒரு குறிப்பிட்ட வரிசையில் உரை மற்றும் குறியீடுகளின் சரம் மூலம் உருவாக்கப்படலாம். ரீஜெக்ஸில் உள்ள பெரும்பாலான எழுத்துக்கள் எழுத்துக்கள் மற்றும் அச்சுக்கலை குறியீடுகள். Regex என்பது கேஸ்-சென்சிட்டிவ், எனவே அதை உருவாக்கி பயன்படுத்தும் போது அதை மனதில் கொள்ளுங்கள்.



ஜாவாவில் ரீஜெக்ஸ் வைட்ஸ்பேஸை எவ்வாறு பயன்படுத்துவது?

ஜாவாவில் முன் வரையறுக்கப்பட்ட வழக்கமான எக்ஸ்பிரஷன் வகுப்பு இல்லை என்றாலும். இருப்பினும், 'ஐ இறக்குமதி செய்வதன் மூலம் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தலாம். java.util.regex ” நூலகம். இது போன்ற சில வகுப்புகள் அடங்கும் ' முறை ', இது ஒரு ரீஜெக்ஸ் வடிவத்தை வரையறுக்கப் பயன்படுகிறது, மேலும் ' போட்டிகளில் ” வகுப்பு இது வடிவத்துடன் தேட பயன்படுகிறது.



ஜாவாவில் ரெஜெக்ஸ் இடைவெளியைப் பயன்படுத்த இரண்டு முறைகள் உள்ளன:





    • Pattern.matches() முறையைப் பயன்படுத்துதல் (முன் வரையறுக்கப்பட்ட ரீஜெக்ஸைப் பயன்படுத்துதல்)
    • பேட்டர்ன் மற்றும் மேட்சர் வகுப்பைப் பயன்படுத்துதல் (பயனர் வரையறுக்கப்பட்ட ரீஜெக்ஸைப் பொருத்துவதற்கு உருவாக்கவும்)

ஜாவாவில் உள்ள வைட்ஸ்பேஸிற்கான ரீஜெக்ஸுடன் இந்த முறைகள் எவ்வாறு செயல்படும் என்பதைப் பார்ப்போம்.

முறை 1: ஜாவாவில் Pattern.matches() முறையுடன் முன் வரையறுக்கப்பட்ட Regex Whitespace ஐப் பயன்படுத்தவும்

ஒரு சரத்தில் இடைவெளிகளைக் கண்டறிய, ஜாவாவில் மூன்று பொதுவான ரீஜெக்ஸ்கள் உள்ளன:



    • \s : இது ஒரு வெள்ளை இடத்தைக் குறிக்கிறது.
    • \s+ : இது பல வெள்ளை இடைவெளிகளைக் குறிக்கிறது.
    • \u0020 : இது ஒரு உரையில் இடைவெளியைக் கண்டறிய ரீஜெக்ஸாகப் பயன்படுத்தப்படும் வெள்ளை இடத்தின் யூனிகோட் ஆகும்.

இந்த ரீஜெக்ஸை நாம் நிலையான முறையில் பயன்படுத்தலாம் ' போட்டிகளில்() 'இன்' முறை ' வர்க்கம். வடிவ வகுப்பு ' java.util.regex ” தொகுப்பு. கீழே Pattern.matches() முறையின் தொடரியல் கொடுக்கப்பட்டுள்ளது:

தொடரியல்

முறை.போட்டிகள் ( '\s' , '' ) ;


குறிப்பிடப்பட்ட முறை இரண்டு வாதங்களை எடுக்கும்: வழக்கமான வெளிப்பாடு மற்றும் பொருந்த வேண்டிய சரம். முதல் வாதம் “\s” என்பது வெள்ளை வெளியின் வழக்கமான வெளிப்பாடு அல்லது ரீஜெக்ஸ் மற்றும் இரண்டாவது வாதம் ”” சரத்தில் உள்ள இடம். இது பூலியன் மதிப்பாக சரி அல்லது தவறை வழங்கும்.

எடுத்துக்காட்டு 1: “\s” WhiteSpace Regex ஐப் பயன்படுத்தவும்

இங்கே நாம் பயன்படுத்துவோம் ' \s Pattern.matches() முறையில் regex. இரண்டாவது வாதமாக முறையில் இடமில்லாமல் ஒரு சரத்தை அனுப்புவோம். இந்த முறை ரீஜெக்ஸ் மற்றும் சரத்தை சரிபார்த்து, '' இல் சேமிக்கப்படும் பூலியன் மதிப்பை வழங்கும். பொருத்துக ” மாறி:

பூலியன் பொருத்துக = முறை. பொருத்தங்கள் ( '\s' , '' ) ;


பொருத்த மாறியின் மதிப்பை “ஐப் பயன்படுத்தி அச்சிடவும் System.out.println() ”முறை:

System.out.println ( 'விண்வெளி உள்ளது:' + பொருத்தம் ) ;



திரும்பிய மதிப்பு ' Pattern.matches() 'முறை' பொய் ” ஏனெனில் அனுப்பப்பட்ட சரத்தில் இடம் இல்லை:


இப்போது நாம் மற்ற ரீஜெக்ஸுடன் இடைவெளியை பொருத்த வேறு சில உதாரணங்களைக் காண்போம்.

எடுத்துக்காட்டு 2: “\s+” WhiteSpace Regex ஐப் பயன்படுத்தவும்

இந்த எடுத்துக்காட்டில், '' \s+ 'ரெஜெக்ஸ்' இல் போட்டிகளில்() பல இடங்களைக் கண்டறியும் முறை:

பூலியன் பொருத்துக = முறை. பொருத்தங்கள் ( '\s+' , '' ) ;


முறையிலிருந்து திரும்பிய முடிவைச் சேமிக்கும் பொருத்த மாறியின் மதிப்பை அச்சிடுக:

System.out.println ( 'விண்வெளி உள்ளது:' + பொருத்தம் ) ;



இரண்டாவது வாதத்தில் இடைவெளிகள் இருப்பதால், இதன் விளைவாக வரும் மதிப்பு ' உண்மை ”:

எடுத்துக்காட்டு 3: “\u0020” WhiteSpace Regex ஐப் பயன்படுத்தவும்

ஜாவாவில் யூனிகோட் எவ்வாறு ரீஜெக்ஸாகப் பயன்படுத்தப்படுகிறது என்பதை இங்கே காண்பிப்போம். குறிப்பிட்ட நோக்கத்திற்காக, நாங்கள் பயன்படுத்துவோம் ' \u0020 ” ரீஜெக்ஸ் வெள்ளை வெளியின் யூனிகோடாக:

பூலியன் பொருத்துக = முறை. பொருத்தங்கள் ( '\u0020' , '' ) ;


திரும்பிய மதிப்பை அச்சிடவும்:

System.out.println ( 'விண்வெளி உள்ளது:' + பொருத்தம் ) ;



Pattern.matches() முறை அச்சிடும் ' உண்மை ”வெள்ளை இடைவெளிகளைக் கொண்ட அனுப்பப்பட்ட சரமாக:


ஜாவாவில் ரீஜெக்ஸைப் பயன்படுத்த மற்ற முறைக்கு செல்லலாம்.

முறை 2: பேட்டர்ன் மற்றும் மேட்சர் வகுப்புடன் பயனர் வரையறுக்கப்பட்ட ரீஜெக்ஸ் வைட்ஸ்பேஸைப் பயன்படுத்தவும்

' முறை 'வகுப்பு ஒரு வடிவத்தை வரையறுக்க அல்லது உருவாக்க பயன்படுகிறது, ' போட்டிகளில் கொடுக்கப்பட்ட வடிவத்தின்படி தேடுவதற்கு வகுப்பு பயன்படுத்தப்படுகிறது. ஒரு ரீஜெக்ஸிற்கான வடிவத்தை '' உதவியுடன் உருவாக்கலாம் தொகுக்க() ” முறை வகுப்பின் முறை. இது ஒரு அளவுருவை மட்டுமே எடுக்கும், எந்த நோக்கத்திற்காகவும் நீங்கள் தொகுக்க விரும்பும் வடிவமாகும்.

தொடரியல்

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


தி போட்டிகளில் வர்க்கம் 'ஐப் பயன்படுத்தி மாதிரியுடன் பொருந்துகிறது போட்டிகளில்() ”முறை. இது ஒரு ' எடுக்கும் லேசான கயிறு ” என மாதிரி.

தொடரியல்

patternVariable.matcher ( லேசான கயிறு ) ;


நாம் மேலே விவாதித்த இடைவெளிகளுக்கு சில முன் வரையறுக்கப்பட்ட ரீஜெக்ஸ் உள்ளன, மீதமுள்ளவை கீழே பட்டியலிடப்பட்டுள்ளன:

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

இப்போது, ​​சில உதாரணங்களைப் பார்க்கலாம்.

எடுத்துக்காட்டு 1: “\\t\\p{Zs}” WhiteSpace Regex ஐப் பயன்படுத்தவும்

இந்த எடுத்துக்காட்டில், அவற்றை எண்ணுவதன் மூலம் இடைவெளிகளின் எண்ணிக்கையைக் கண்டுபிடிப்போம். முதலில், நாம் ஒரு சரத்தை உருவாக்குவோம் ' கள் ” மற்றும் அதை கன்சோலில் அச்சிடவும்:

சரம் கள் = '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 ( கள் ) ;


மேலே உள்ள எடுத்துக்காட்டில், நாங்கள் ஒரு ' போது ஒரு சரத்தில் இடைவெளிகளை எண்ணி அவற்றை அச்சிட வளையம்:



கொடுக்கப்பட்ட வெளியீடு நமது சரம் ' லினக்ஸ் குறிப்புக்கு வரவேற்கிறோம் ” மூன்று இடைவெளிகளைக் கொண்டுள்ளது:



ஜாவாவில் ரீஜெக்ஸ் இடைவெளியைப் பயன்படுத்த உங்களுக்கு உதவும் அனைத்து எளிய முறைகளையும் நாங்கள் தொகுக்கிறோம்.

முடிவுரை

இடைவெளிக்கு பல வழக்கமான வெளிப்பாடுகள் உள்ளன. \s ”,” \s+ ”,” \u0020 ”,” \\t\\p{Zs} ', மற்றும் ' \\p{Zs} ”. இந்த ரீஜெக்ஸ்கள் பேட்டர்ன் வகுப்பின் மேட்ச்ஸ்() முறையில் அல்லது பேட்டர்ன் கிளாஸ் மூலம் ஒரு பேட்டர்னை வரையறுத்து மேட்சர் வகுப்பைப் பயன்படுத்தி பொருத்துவதன் மூலம் பயன்படுத்தப்படுகின்றன. பொதுவாகப் பயன்படுத்தப்படும் ரெஜெக்ஸ் இடைவெளி \s மற்றும் \s+ ஆகும். இந்த டுடோரியலில், ஜாவாவில் ரீஜெக்ஸ் இடைவெளியைப் பயன்படுத்துவதற்கான அனைத்து முறைகளையும் நாங்கள் உள்ளடக்கியுள்ளோம்.