StringTokenizer, String.replace, மற்றும் String.split

"ஹாய், அமிகோ!"

"எனக்குத் தெரிந்தவரை, ரிஷி உங்களிடம் வழக்கமான எக்ஸ்ப்ரெஷன்களைப் பற்றி ஏற்கனவே சொல்லியிருக்கிறார்."

"ஆம், இது மிகவும் சுவாரஸ்யமாக இருந்தது."

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

"எளிமையான கேள்வியுடன் ஆரம்பிக்கலாம்:"

1) வழக்கமான வெளிப்பாட்டால் குறிப்பிடப்பட்ட வடிவத்துடன் ஒரு சரம் பொருந்துகிறதா என்பதை நான் எவ்வாறு சரிபார்க்க வேண்டும்?

"இதற்குப் பொருத்த முறை உள்ளது. வழக்கமான வெளிப்பாட்டைக் கொண்ட ஒரு சரத்தை நீங்கள் அனுப்பினால், அந்த முறை சரி அல்லது தவறு எனத் திரும்பும்."

boolean matches(String regex)

String s = "Good news, everyone!";
Boolean test = s.matches("news\\.*");

false (the String doesn't start with "news")

2) பொருந்தும் அனைத்து துணைச்சரங்களையும் வெவ்வேறு சரங்களுடன் எவ்வாறு மாற்றுவது?

"இதற்கு இரண்டு முறைகள் உள்ளன."

" அனைத்து மாற்றும் முறை ஒரு துணை சரத்தின் அனைத்து நிகழ்வுகளையும் மற்றொரு சரத்துடன் மாற்றுகிறது."

" ரீப்ளேஸ்ஃபர்ஸ்ட் முறையானது, அனுப்பப்பட்ட சப்ஸ்ட்ரிங்கின் முதல் நிகழ்வை ஒரு குறிப்பிட்ட சரத்துடன் மாற்றுகிறது."

String replaceAll(String regex, String replacement)

String s = "Good news, everyone!";
String s2 = s.replaceAll ("e\\.","EX");

s2 == "Good nEXs EXEXyonEX";

String replaceFirst(String regex, String replacement)

String s = "Good news, everyone!";
String s2 = s.replaceFirst("e\\.","EX");

s2 == "Good nEXs, everyone!";

3) ஒரு சரத்தை எவ்வாறு பகுதிகளாகப் பிரிப்பது?

"இதற்காக, எங்களிடம் பிளவு முறை உள்ளது, இது வரையறுக்கும் முகமூடியை எடுக்கும்:"

String[] split(String regex)

String s = "Good news everyone!";
String[] ss = s.split("ne");
System.out.println(Arrays.toString(ss));

[Good , ws everyo, !]
"Good ", "ws everyo", "!";

" ஸ்ட்ரிங்டோக்கனைசர் கிளாஸ் ஒரு சரத்தை பகுதிகளாகப் பிரிக்க மற்றொரு வழி ."

"இந்த வகுப்பு வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துவதில்லை. அதற்குப் பதிலாக, நீங்கள் பிரிப்புகளின் தொகுப்பைக் கொண்ட ஒரு சரத்தில் கடந்து செல்வீர்கள். இந்த அணுகுமுறையின் நன்மை என்னவென்றால், இது முழு சரத்தையும் ஒரே நேரத்தில் துண்டுகளாக உடைக்காது, மாறாக அது மெதுவாக நகர்கிறது. ஆரம்பம் முதல் இறுதி வரை."

"வகுப்பில் ஒரு கன்ஸ்ட்ரக்டர் மற்றும் இரண்டு முறைகள் உள்ளன. நாங்கள் பிரித்து வைத்திருக்கும் சரத்தை நீங்கள் கன்ஸ்ட்ரக்டருக்குள் அனுப்ப வேண்டும், அதனுடன் பிரிக்கும் எழுத்துகளின் தொகுப்பைக் கொண்டிருக்கும்."

நெக்ஸ்ட் டோக்கன் முறை அடுத்த டோக்கனை (சப்ஸ்ட்ரிங்) வழங்கும்.

இன்னும் திரும்பப் பெறாத துணைச்சரங்கள் இருந்தால் hasMoreTokens() முறை உண்மை எனத் திரும்பும்.

boolean hasMoreTokens()

String nextToken()

String s = "Good news, everyone!";

StringTokenizer tokenizer =
new StringTokenizer(s,"ne");
while (tokenizer.hasMoreTokens())
{
String token = tokenizer.nextToken();
System.out.println(token);
}

Good
ws
v
ryo
!

"இரண்டாவது ஸ்டிரிங்கில் உள்ள எந்த எழுத்தும் StringTokenizer கன்ஸ்ட்ரக்டருக்கு அனுப்பப்பட்டால் அது டிலிமிட்டராகக் கருதப்படுகிறது."

"மீண்டும் ஒருமுறை, எல்லாம் தெளிவாகத் தெரிகிறது. இந்தக் குறியீட்டை என்னால் இப்போதே எழுத முடியாமல் போகலாம், ஆனால் இங்கு என்ன நடக்கிறது என்பது எனக்குப் புரிகிறது."

"அருமையானது, நீங்கள் தலைப்பில் தேர்ச்சி பெற்றுள்ளீர்கள் என்று நாங்கள் கருதுகிறோம்."