ஜாவாவில் சரங்களுடன் பணிபுரிதல்

1. சரங்களை ஒப்பிடுதல்

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

boolean equals(String str)

boolean equalsIgnoreCase(String str)

int compareTo(String str)

int compareToIgnoreCase(String str)

boolean regionMatches(int toffset, String str, int offset, int len)

boolean startsWith(String prefix)

boolean endsWith(String suffix)

பயனரிடம் கோப்பிற்கான பாதையைக் கேட்டு அதன் நீட்டிப்பின் அடிப்படையில் கோப்பு வகையைச் சரிபார்க்கும் நிரலை நீங்கள் எழுத விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். அத்தகைய நிரலின் குறியீடு இப்படி இருக்கலாம்:

Scanner console = new Scanner(System.in);
String path = console.nextLine();

if (path.endsWith(".jpg") || path.endsWith(".jpeg"))
{
   System.out.println("This is a jpeg!");
}
else if (path.endsWith(".htm") || path.endsWith(".html"))
{
   System.out.println("This is an HTML page");
}
else if (path.endsWith(".doc") || path.endsWith(".docx"))
{
   System.out.println("This is a Word document");
}
else
{
   System.out.println("Unknown format");
}

2. சப்ஸ்ட்ரிங்க்களைத் தேடுகிறது

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

int indexOf(String str)

int indexOf(String str, int index)

int lastIndexOf(String str)

int lastIndexOf(String str, int index)

boolean matches(String regex)

மற்றும் முறைகள் பெரும்பாலும் indexOf(String)இணைந்து indexOf(String, index)பயன்படுத்தப்படுகின்றன. முதல் முறையானது, தற்போதைய சரத்தில் அனுப்பப்பட்ட சப்ஸ்ட்ரிங்கின் முதல் நிகழ்வைக் கண்டறிய உங்களை அனுமதிக்கிறது. இரண்டாவது முறையானது, முதல் குறியீட்டு எழுத்துகளைத் தவிர்ப்பதன் மூலம் இரண்டாவது, மூன்றாவது, போன்ற நிகழ்வுகளைக் கண்டறிய உங்களை அனுமதிக்கிறது.

எங்களிடம் " https://domain.com/about/reviews " போன்ற url உள்ளது என்று வைத்துக்கொள்வோம் , மேலும் டொமைன் பெயரை " codegym.cc " என்று மாற்ற விரும்புகிறோம் . Url கள் பல்வேறு டொமைன் பெயர்களைக் கொண்டிருக்கலாம், ஆனால் பின்வருவனவற்றை நாங்கள் அறிவோம்:

• டொமைன் பெயருக்கு முன்னால் இரண்டு முன்னோக்கி சாய்வுகள் உள்ளன — " //"
• டொமைன் பெயரைத் தொடர்ந்து ஒற்றை முன்னோக்கி சாய்வு — " /"

அத்தகைய நிரலுக்கான குறியீடு எப்படி இருக்கும் என்பது இங்கே:

Scanner console = new Scanner(System.in);
String path = console.nextLine();

int index = path.indexOf("//");
int index2 = path.indexOf("/", index + 2);

String first = path.substring(0, index + 2);
String last = path.substring(index2);

String result = first + "codegym.cc" + last;
System.out.println(result);

மற்றும் முறைகள் அதே வழியில் செயல்படுகின்றன, சரத்தின் முடிவில் இருந்து ஆரம்பம் வரை தேடல் மட்டுமே செய்யப்படுகிறது lastIndexOf(String).lastIndexOf(String, index)

3. துணை சரங்களை உருவாக்குதல்

சரங்களை ஒப்பிடுவது மற்றும் சப்ஸ்ட்ரிங்க்களைக் கண்டுபிடிப்பதைத் தவிர, மிகவும் பிரபலமான மற்றொரு செயலும் உள்ளது: ஒரு சரத்திலிருந்து ஒரு சரத்தைப் பெறுதல். அது நிகழும்போது, ​​முந்தைய உதாரணம் உங்களுக்கு ஒரு substring()முறை அழைப்பைக் காட்டியது, அது ஒரு சரத்தின் ஒரு பகுதியை திரும்பப் பெறுகிறது.

தற்போதைய சரத்திலிருந்து துணைச்சரங்களை வழங்கும் 8 முறைகளின் பட்டியல் இங்கே:

String substring(int beginIndex, int endIndex)

String repeat(int count)

String replace(char oldChar, char newChar)

String replaceFirst(String regex, String replacement)

String replaceAll(String regex, String replacement)

String toLowerCase()

String toUpperCase()

String trim()

கிடைக்கக்கூடிய முறைகளின் சுருக்கம் இங்கே:

substring(int beginIndex, int endIndex)முறை

இந்த substringமுறை தற்போதைய சரத்தில் உள்ள எழுத்துக்களைக் கொண்ட புதிய சரத்தை வழங்குகிறது, குறியீட்டுடன் எழுத்துக்குறியில் தொடங்கி beginIndexஇல் முடிவடைகிறது endIndex. ஜாவாவில் உள்ள அனைத்து இடைவெளிகளையும் போலவே, குறியீட்டுடன் கூடிய எழுத்து endIndexஇடைவெளியில் சேர்க்கப்படவில்லை. எடுத்துக்காட்டுகள்:

"Hellos".substring(0, 3);

"Hel"

"Hellos".substring(1, 4);

"ell"

"Hellos".substring(1, 6);

"ellos"

"Hellos".substring(1);

"ellos"

அளவுரு குறிப்பிடப்படவில்லை என்றால் endIndex(இது சாத்தியம்), பின்னர் தொடக்க அட்டவணையில் உள்ள எழுத்து முதல் சரத்தின் இறுதி வரை சப்ஸ்ட்ரிங் எடுக்கப்படும்.

repeat(int n)முறை

ரிப்பீட் முறையானது தற்போதைய சரம் nநேரங்களை மீண்டும் மீண்டும் செய்கிறது. உதாரணமாக:

"Hello".repeat(3);

"HelloHelloHello"

"Hello".repeat(2);

"HelloHello"

"Hello".repeat(1);

"Hello"

"Hello".repeat(0);

""

replace(char oldChar, char newChar)முறை

இந்த replace()முறை ஒரு புதிய சரத்தை வழங்குகிறது, அதில் அனைத்து எழுத்துக்களும் oldCharஎழுத்துடன் மாற்றப்படும் newChar. இது சரத்தின் நீளத்தை மாற்றாது. உதாரணமாக:

"Programming".replace('Z', 'z');

"Programming"

"Programming".replace('g', 'd');

"Prodrammind"

"Programming".replace('a', 'e');

"Progremming"

"Programming".replace('m', 'w');

"Prograwwing"

replaceFirst()மற்றும் replaceAll()முறைகள்

இந்த replaceAll()முறை ஒரு துணை சரத்தின் அனைத்து நிகழ்வுகளையும் மற்றொன்றுடன் மாற்றுகிறது. முறையானது, replaceFirst()அனுப்பப்பட்ட சப்ஸ்ட்ரிங்கின் முதல் நிகழ்வை குறிப்பிட்ட சப்ஸ்ட்ரிங் மூலம் மாற்றுகிறது. மாற்றப்பட வேண்டிய சரம் வழக்கமான வெளிப்பாடு மூலம் குறிப்பிடப்படுகிறது. ஜாவா மல்டித்ரெடிங் தேடலில் வழக்கமான வெளிப்பாடுகளை ஆராய்வோம் .

எடுத்துக்காட்டுகள்:

"Good news everyone!".replaceAll("e.", "EX");

"Good nEXs EXEXyonEX"

"Good news everyone!".replaceAll("o.", "-o-");

"G-o-d news every-o-e!"

"Good news everyone!".replaceFirst("e.", "EX");

"Good nEXs everyone!"

"Good news everyone!".replaceFirst("o.", "-o-");

"G-o-d news everyone!"

toLowerCase() and toUpperCase()முறைகள்

வகுப்பின் முறைகளை அழைப்பது பற்றி முதலில் அறிந்தபோது இந்த முறைகளை நாங்கள் அறிந்தோம் String.

trim()முறை

இந்த trim()முறை ஒரு சரத்திலிருந்து முன்னணி மற்றும் பின்தங்கிய இடைவெளிகளை நீக்குகிறது. சரத்திற்குள் இருக்கும் இடைவெளிகளைத் தொடாது (அதாவது ஆரம்பத்திலோ அல்லது முடிவிலோ அல்ல). எடுத்துக்காட்டுகள்:

"     ".trim();

""

"Hello".trim();

"Hello"

" Hello\n how are you?\n   ".trim();

"Hello\n how are you?\n"

"  Password\n   \n ".trim();

"Password\n   \n"