- 1 1. Java trim() වැදගත් වීමේ හේතු සහ මෙම ලිපියේ අරමුණ
- 2 2. Java trim() ක්රමය පිළිබඳ මූලික දැනුම
- 3 3. trim() පිළිබඳ වැදගත් අවධානම් සහ සාමාන්ය වැරදි
- 4 4. Java 11 සහ ඊට පසු strip() ක්රම සමඟ සංසන්දනය
- 5 5. trim() විස්තාරණය: ප්රායෝගික තාක්ෂණ සහ ප්රයෝජනවත් පුස්තකාල
- 6 6. trim() සහ strip() සඳහා ප්රායෝගික භාවිතා
- 7 7. නිතර අසන ප්රශ්න (FAQ)
- 8 8. සාරාංශය
- 9 9. යොමු සබැඳි
1. Java trim() වැදගත් වීමේ හේතු සහ මෙම ලිපියේ අරමුණ
සොෆ්ට්වෙයා සංවර්ධනයේ, “අවශ්ය නොවන හිස් ඉඩ” හසුරවීම සුළු කාර්යයක් ලෙස පෙනෙන්නට හැකි වුවද, එය ඇත්තටම ඉතා වැදගත් කාර්යයකි. Java හි, trim() ක්රමය පරිශීලක ඇතුළත් කිරීමේ හසුරවීම, ගොනු කියවීම, සහ API ඒකාබද්ධ කිරීම වැනි අවස්ථා වල බොහෝ විට පෙනේ.
උදාහරණයක් ලෙස, ඇතුළත් කිරීමේ පෝරමයකින් අනිසි ඉඩකඩ සමඟ දත්ත සුරැකි නම්, එය දත්ත ගබඩා සමග අස්ථිරතාවයක් හෝ අනපේක්ෂිත දෝෂ සහ අසමතුලිතතා ඇති කරයි. එබැවින්, බොහෝ Java ඉංජිනේරුවන් සහ සිසුන් ස්ට්රින්ග් වල අතිරේක හිස් ඉඩ ඉක්මනින් ඉවත් කිරීමට කැමති වෙති.
“java trim” සෙවීම කරන අය සාමාන්යයෙන් පහත ප්රශ්න අසති:
- මට හිස් ඉඩ නිවැරදිව ඉවත් කර ගැනීමට කෙසේද?
- එය පූර්ණ-පළල (ජපන්) ඉඩකඩද ඉවත් කළ හැකිද?
trim()සහstrip()අතර වෙනස කුමක්ද?- මට අවධානයට ගත යුතු සාමාන්ය වැරදි කුමනවාද?
මෙම ලිපිය Java හි trim() ක්රමය මූලික කරුණු සිට වැදගත් අවධානම් සහ උසස් භාවිත උදාහරණ දක්වා පැහැදිලි කරයි. එය Java ඉගෙන ගන්නා ආරම්භකයන්ට පමණක් නොව, වාස්තුක පද්ධතිවල වැඩ කරන පළපුරුදු ඉංජිනේරුවන්ටද ප්රයෝජනවත් වන ලෙස ලියන ලදී.
මෙම ලිපිය කියවීමෙන්, ඔබට හිස් ඉඩ හසුරවීම පිළිබඳ ගැඹුරු අවබෝධයක් ලැබෙන අතර, වඩා ශක්තිමත්, දෝෂ‑රහිත Java කේතයක් ලිවීමට හැකි වේ. දැන් trim() මූලික කරුණු සමඟ ආරම්භ කරමු.
2. Java trim() ක්රමය පිළිබඳ මූලික දැනුම
Java හි ස්ට්රින්ග් එකක අනිවාර්ය නොවන හිස් ඉඩ ඉවත් කිරීමට අවශ්ය වන විට, මුලින්ම මතකයට එන ක්රමය trim() වේ. මෙම කොටස එහි මූලික හැසිරීම සහ භාවිතය සාරාංශ කරයි.
trim() ක්රමය කුමක්ද?
trim() යනු Java හි String පන්තිය විසින් ලබා දෙන සාමාන්ය ක්රමයකි. එහි ප්රධාන කාර්යය ස්ට්රින්ග් එකේ ආරම්භය සහ අවසානයේ ඉඩ, ටැබ්, සහ පේළි බිඳු වැනි හිස් ඉඩ අක්ෂර ඉවත් කිරීමයි.
පරිශීලකයෙකු දෙපැත්තේම අවශ්ය නොවන ඉඩකඩ සමඟ ස්ට්රින්ග් එකක් ඇතුළත් කළාමත්, trim() ඔබට එය පහසුවෙන් පිරිසිදු කිරීමට ඉඩ දේ.
ව්යුහය සහ සරල භාවිතය
String input = " Hello World! ";
String result = input.trim();
System.out.println(result); // → "Hello World!"
මෙම උදාහරණයේ, " Hello World! " හි ආරම්භයේ සහ අවසානයේ ඉඩකඩ ඉවත් කර, ප්රතිඵලය "Hello World!" වේ.
trim() මගින් ඉවත් කරන අක්ෂර
trim() ක්රමය Unicode අගය 32 හෝ ඊට අඩු වන හිස් ඉඩ අක්ෂර ඉවත් කරයි, ඒවා අතර:
- අඩි-පළල ඉඩ (‘ ‘)
- ටැබ් (‘\t’)
- නව පේළිය (‘\n’)
- කාරියජ්ය ආපසු (‘\r’)
- ලම්බ ටැබ් (‘\u000B’)
- ෆෝම් ෆීඩ් (‘\f’)
මුල් ස්ට්රින්ග් වෙනස් නොවේ (අපරिवර්තනය)
වැදගත් කරුණක් වන්නේ trim() මුල් ස්ට්රින්ග් එක වෙනස් නොකරන බවයි. Java String වස්තු අවිවර්තනීය (immutable) වන බැවින්, trim() සෑම විටම නව ස්ට්රින්ග් උදාහරණයක් ලබා දෙයි.
String original = " test ";
String trimmed = original.trim();
// original remains " test "
// trimmed becomes "test"
පූර්ණයෙන් හිස් ඉඩක් පමණක් ඇති ස්ට්රින්ග් එකක් නම් කුමක් වේද?
මුල් ස්ට්රින්ග් එක පූර්ණයෙන් හිස් ඉඩක් පමණක් (උදාහරණයක් ලෙස, " ") ඇතුළත් කර ඇත්නම්, trim() ප්රතිඵලය හිස් ස්ට්රින්ග් එකක් ("") වේ.
String blank = " ";
String trimmedBlank = blank.trim();
System.out.println(trimmedBlank.length()); // → 0
පෙන්වා ඇති පරිදි, trim() Java හි මූලිකතම හිස් ඉඩ ඉවත් කිරීමේ ක්රමය වේ.
3. trim() පිළිබඳ වැදගත් අවධානම් සහ සාමාන්ය වැරදි
trim() ඉතා පහසු වුවද, බොහෝ විට වැරදි ලෙස තේරුම් ගන්නා වැදගත් කරුණු කිහිපයක් ඇත. මෙම කොටස ක්රමය අපේක්ෂා කරන පරිදි ක්රියා නොකරන සාමාන්ය අවස්ථා ආවරණය කරයි.
පූර්ණ-පළල ඉඩකඩ ඉවත් නොකෙරේ
ඉතා සාමාන්ය වැරදි අදහසක් වන්නේ trim() පූර්ණ-පළල ඉඩකඩ (U+3000) ඉවත් කරයි යැයි සිතීමයි. වාස්තු විශේෂයෙන්, trim() අඩි-පළල ඉඩකඩ සහ පාලන අක්ෂර පමණක් ඉවත් කරයි.
පූර්ණ-පළල ඉඩකඩ ජපන් පාඨ ඇතුළත් කිරීමේ හෝ පිටපත් කරගත් අන්තර්ගතයේ බොහෝ විට පෙනේ, සහ trim() කැඳවීමෙන් පසු ඒවා තවමත් රැඳී ඇත.
උදාහරණය: පූර්ණ-පළල ඉඩකඩ රැඳී ඇත
String s = " Hello World! "; // Full-width spaces at both ends
System.out.println(s.trim()); // → " Hello World! "
මැද හිස් ඉඩකඩ ඉවත් නොකෙරේ
trim() සූත්රයක් (string) එකේ ආරම්භය සහ අවසානයේ පමණක් හිස් ඉඩ (whitespace) ඉවත් කරයි.
සූත්රය තුළ ඇති හිස් ඉඩ (whitespace) වෙනස් නොවේ.
උදාහරණය: අභ්යන්තර ඉඩ රඳා පවතී
String s = "Java trim example";
System.out.println(s.trim()); // → "Java trim example"
අභ්යන්තර ඉඩ ඉවත් කිරීමට, replaceAll() වැනි වෙනත් ක්රම අවශ්ය වේ.
හිස් සූත්ර සහ null අගයන්
- සූත්රය හිස් නම් හෝ පමණක් හිස් ඉඩ (whitespace) අඩංගු නම්,
trim()හිස් සූත්රයක් 반환 කරයි. nullමතtrim()කැඳවන්නේ නම්,NullPointerExceptionඑකක් සිදුවේ. අවශ්ය විට නිතර null පරීක්ෂාවක් කරන්න.
උදාහරණය: Null පරීක්ෂාව
String s = null;
if (s != null) {
System.out.println(s.trim());
} else {
System.out.println("The value is null");
}
කාර්ය සාධනය සහ මතක සැලකිලි
හිස් ඉඩ කිසිවක් ඉවත් නොකළත්, trim() නව සූත්ර වස්තුවක් නිර්මාණය කරයි. විශාල ප්රමාණයේ සූත්ර සැකසීමේදී, trim() අධික ලෙස භාවිතා කිරීම මතක භාවිතය වැඩි කරයි. විශාල දත්ත කට්ටලයන් සමඟ කටයුතු කරන විට ඔබේ තර්කය සැලකිලිමත් ලෙස සැලසුම් කරන්න.
4. Java 11 සහ ඊට පසු strip() ක්රම සමඟ සංසන්දනය
Java 11 සිට, strip(), stripLeading(), stripTrailing() වැනි නව ක්රම හඳුන්වා දී ඇත. මෙම ක්රම trim() ට වඩා වඩාත් ලච්ච හිස් ඉඩ (whitespace) සැකසීම ලබා දෙයි.
strip() හි විශේෂාංග
strip() සූත්රයක් දෙපාර්ශ්වයෙන්ම සියලු Unicode-නිර්වචිත හිස් ඉඩ අක්ෂර ඉවත් කරයි, පූර්ණ-පළල ඉඩ (full-width spaces) ඇතුළුව.
උදාහරණය: strip() පූර්ණ-පළල ඉඩ ඉවත් කරයි
String s = " Hello World! ";
System.out.println(s.strip()); // → "Hello World!"
stripLeading() සහ stripTrailing()
stripLeading(): ආරම්භයේ හිස් ඉඩ පමණක් ඉවත් කරයිstripTrailing(): අවසානයේ හිස් ඉඩ පමණක් ඉවත් කරයි
උදාහරණය: අංශික Trimming
String s = " Hello World! ";
System.out.println(s.stripLeading()); // → "Hello World! "
System.out.println(s.stripTrailing()); // → " Hello World!"
වෙනස්කම් සාරාංශය
| Method | Whitespace Removed | Java Version |
|---|---|---|
| trim() | Half-width spaces and control characters | Java 1.0+ |
| strip() | All Unicode whitespace | Java 11+ |
| stripLeading() | Leading Unicode whitespace | Java 11+ |
| stripTrailing() | Trailing Unicode whitespace | Java 11+ |
5. trim() විස්තාරණය: ප්රායෝගික තාක්ෂණ සහ ප්රයෝජනවත් පුස්තකාල
trim() සහ strip() ශක්තිමත් වුවද, අභ්යන්තර හිස් ඉඩ ඉවත් කිරීම හෝ සංකීර්ණ නීති යෙදීම වැනි වැඩි පාලනය අවශ්ය වන අවස්ථා ඇත.
replaceAll() සමඟ අභිරුචි Trimming
String s = " Hello Java ";
String result = s.replaceAll("^[\\s ]+|[\\s ]+$", "");
System.out.println(result); // → "Hello Java"
අභ්යන්තර හිස් ඉඩ ඉවත් කිරීම
String s = " J a v a ";
String result = s.replaceAll("\\s+", "");
System.out.println(result); // → "Java"
ලූප්-අධාරිත අභිරුචි සැකසීම
සංකීර්ණ දත්ත-පිරිසිදු කිරීමේ අවස්ථා වල, ලූප් භාවිතා කර අභිරුචි trimming තර්කය ක්රියාත්මක කිරීම සුදුසු විය හැක.
Apache Commons Lang – StringUtils
import org.apache.commons.lang3.StringUtils;
String input = " ";
String result = StringUtils.trimToNull(input);
// Result is null
Guava – CharMatcher
import com.google.common.base.CharMatcher;
String s = " Java ";
String result = CharMatcher.whitespace().trimFrom(s);
System.out.println(result); // → "Java"
6. trim() සහ strip() සඳහා ප්රායෝගික භාවිතා
මෙම ක්රම වාස්තුකාලීන සංවර්ධන අවස්ථා වල පුළුල් ලෙස භාවිතා වේ.
පරිශීලක ඇතුළත් කිරීමේ පෙර සැකසීම
String email = request.getParameter("email");
email = email != null ? email.trim() : null;
CSV හෝ පෙළ ගොනු දත්ත පිරිසිදු කිරීම
String[] items = line.split(",");
for (int i = 0; i < items.length; i++) {
items[i] = items[i].strip();
}
API ඒකාබද්ධ කිරීමේ සාමාන්යීකරණය
හිස් ඉඩ සාමාන්යීකරණය අසමතුලිතතා සහ අනුපිළිවෙළ දත්ත වලින් වැළැක්වීමට උපකාරී වේ.
සූත්ර සංසන්දනය සහ සෙවීම
if (userInput.trim().equals(databaseValue.trim())) {
// Matching logic
}
7. නිතර අසන ප්රශ්න (FAQ)
ප්ර.1. මට trim() හෝ strip() භාවිතා කළ යුතුද?
A.
trim() Java 8 හෝ එයට පෙර සඳහා භාවිතා කරන්න. Java 11+ හි සම්පූර්ණ Unicode හිස් ඉඩ සහය සඳහා strip() භාවිතා කරන්න.
ප්ර.2. පූර්ණ-පළල ඉඩ පමණක් කෙසේ ඉවත් කළ හැකිද?
A.
replaceAll() සමඟ නියමිත ප්රකාශනයක් භාවිතා කරන්න.
Q3. අභ්යන්තර ඉඩ කොහොමද ඉවත් කරන්නේ?
A.
replaceAll("\\s+", "") භාවිතා කරන්න.
Q4. Java 8 හි strip() ක්රියාවලිය අනුකරණය කළ හැදුවේද?
A.
පූර්ණයෙන් නොවෙයි, නමුත් නියමිත ප්රකාශන හෝ බාහිර පුස්තකාල භාවිතා කළ හැක.
Q5. trim() ක්රියාවලිය null මත කැඳවූ විට කුමක් සිදුවේ?
A.
NullPointerException එකක් සිදුවේ.
Q6. කාර්ය සාධන ගැටළු තිබේද?
A.
ඔව්. සෑම කැඳවීමක්ම නව string වස්තුවක් නිර්මාණය කරයි, එබැවින් අවශ්ය තැන්වල පමණක් භාවිතා කරන්න.
8. සාරාංශය
මෙම ලිපිය Java හි trim() ක්රියාවලිය පිළිබඳව ගැඹුරු විස්තරයක් සපයයි, එහි සීමා සහ strip() වැනි නව විකල්පයන් ඇතුළත් කරමින්. මෙම වෙනස්කම් තේරුම් ගැනීම දත්ත ගුණාත්මකභාවය වැඩිදියුණු කිරීමට, සුක්ෂ්ම දෝෂ වැළැක්වීමට, සහ වඩා විශ්වාසදායක Java යෙදුම් ගොඩනැගීමට උපකාරී වේ.
