Mastering Java Strings: An SC Guide

කොහොමද යාලුවනේ! ඔයාලා හැමෝම Java programming කරනකොට, නැත්නම් වෙන ඕනෑම programming language එකක වැඩ කරනකොට, නිතරම වගේ පාවිච්චි කරන දෙයක් තමයි Strings කියන්නේ. නම්, ලිපිනයන්, messages, file paths වගේ ගොඩක් දේවල් store කරන්නයි, manipulate කරන්නයි අපිට Strings ඕන වෙනවා. ඉතින් අද අපි කතා කරන්න යන්නේ Java වල Strings ගැන විස්තරාත්මකව. මේක ඔයාලට Java Strings ගැන හොඳ අවබෝධයක් ගන්න අනිවාර්යයෙන්ම උදව් වෙයි!

අපි බලමු Strings කියන්නේ මොනවද, ඒවායේ තියෙන විශේෂතා මොනවද, ඒවට පාවිච්චි කරන්න පුළුවන් Methods මොනවද, සහ Strings එකතු කරන්නේ කොහොමද වගේ දේවල්.

String එකක් කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, String එකක් කියන්නේ characters sequence එකක්. ඒ කියන්නේ අකුරු, ඉලක්කම්, symbols වගේ දේවල් එක පෙළට තියෙන එකක්. Java වල String කියන්නේ primitive data type එකක් නෙවෙයි, Object එකක්. ඒ කියන්නේ String class එකේ instance එකක්. මේක අපිට ඕන විදිහට හදාගන්න පුළුවන්, ගොඩක් operations කරන්න පුළුවන්.

String එකක් declare කරන්නේ මෙන්න මෙහෙමයි:

String greeting = "හෙලෝ ලෝකය!";
String name = new String("අලුත් String එකක්"); // මේ විදිහටත් ගන්න පුළුවන්

සාමාන්‍යයෙන් අපි පළවෙනි විදිහට තමයි String declare කරන්නේ. ඒක තමයි පහසුම සහ recommend කරන ක්‍රමය. Java String Pool එකේ ක්‍රියාකාරීත්වය නිසා ඒක වඩාත් කාර්යක්ෂමයි.

String එකක 'නොවෙනස්වනසුලු බව' – Immutability

Java Strings ගැන කතා කරනකොට අනිවාර්යයෙන්ම දැනගන්න ඕන වැදගත්ම concept එකක් තමයි Immutability කියන්නේ. Immutability කියන්නේ, String object එකක් හදපු ගමන්, ඒකේ තියෙන content එක ආයේ වෙනස් කරන්න බෑ කියන එක. ඒ කියන්නේ, ඔයා String එකකට මොකක් හරි වෙනසක් කරන්න හැදුවොත් (උදාහරණයක් විදිහට අකුරක් replace කරන්න, String එකට තව String එකක් එකතු කරන්න), Java කරන්නේ අලුත් String object එකක් හදලා ඒ වෙනසත් එක්ක ඒකේ content එක දාන එකයි. මුල් String object එක එහෙම්මම වෙනස් නොවී තියෙනවා.

අපි මේක පොඩි උදාහරණයකින් තේරුම් ගමු:

String s = "Java";
System.out.println(s); // Output: Java

s = s + " Programming"; // මේකෙන් අලුත් String එකක් හැදෙනවා
System.out.println(s); // Output: Java Programming

මේ උදාහරණයේදී, "Java" කියන String එක හැදුවට පස්සේ, s = s + " Programming" කියලා දුන්නම, "Java Programming" කියලා අලුත් String object එකක් හැදෙනවා. s කියන reference එක දැන් අලුත් String එකට point කරනවා. මුල් "Java" කියන String object එක memory එකේ එහෙම්මම තියෙනවා (ඒකට reference එකක් නැති නිසා, Garbage Collector එකෙන් පස්සේ remove වෙයි).

ඇයි මේ Immutability වැදගත්?

• Thread Safety: String object එකක් වෙනස් වෙන්නේ නැති නිසා, එකම String එකක් එකම වෙලාවේ Threads කීපයකට බය නැතුව share කරන්න පුළුවන්. Data corruption වෙන්නේ නෑ.
• Security: Network connections, database connections වලදී usernames, passwords වගේ sensitive data Strings විදිහට යවනවා. ඒ Strings immutable නිසා, ඒවා transfer වෙන අතරතුරදී කවුරු හරි ඒවා වෙනස් කරන එක වළක්වනවා.
• Performance (String Pool): Java String Pool එක Immutability මත පදනම් වෙලා තමයි වැඩ කරන්නේ. එකම content එක තියෙන Strings වෙන වෙනම හදන්නේ නැතුව, තියෙන String object එකම share කරනවා. මේක memory usage එක අඩු කරනවා.

String Methods ටිකක් බලමු!

Java String class එකේ String manipulate කරන්න පුළුවන් Methods ගොඩක් තියෙනවා. මේවා ඔයාලගේ දෛනික coding වලදී ගොඩක් ප්‍රයෝජනවත් වෙයි. අපි දැන් වැදගත් Methods කීපයක් බලමු.

1. length()

String එකක තියෙන characters ගණන දැනගන්න මේ Method එක පාවිච්චි කරනවා.

String text = "හෙලෝ!";
int len = text.length(); // len = 5
System.out.println("දිග: " + len);

2. charAt(int index)

String එකක තියෙන specific index එකක character එක ගන්න මේක පාවිච්චි කරනවා. මතක තියාගන්න, String index එක 0 ඉඳන් තමයි පටන් ගන්නේ.

String word = "Java";
char firstChar = word.charAt(0); // firstChar = 'J'
char lastChar = word.charAt(word.length() - 1); // lastChar = 'a'
System.out.println("පළමු අකුර: " + firstChar);

3. substring(int beginIndex) / substring(int beginIndex, int endIndex)

String එකකින් කොටසක් (substring) කපාගන්න මේ Methods පාවිච්චි කරනවා.

String sentence = "Java Programming is fun.";
String sub1 = sentence.substring(5); // sub1 = "Programming is fun."
String sub2 = sentence.substring(0, 4); // sub2 = "Java" (endIndex එක ඇතුලත් වෙන්නේ නෑ)
System.out.println("Sub String 1: " + sub1);
System.out.println("Sub String 2: " + sub2);

4. equals(Object another) / equalsIgnoreCase(String another)

Strings දෙකක් සමානද කියලා බලන්න මේ Methods පාවිච්චි කරනවා. equals() කියන්නේ case-sensitive. equalsIgnoreCase() කියන්නේ case-insensitive.

වැදගත්: Strings දෙකක් == operator එකෙන් compare කරන්න එපා! ඒකෙන් බලන්නේ references සමානද කියලා මිසක් content එක නෙවෙයි. Content එක බලන්න නම් equals() පාවිච්චි කරන්න.

String s1 = "හෙලෝ";
String s2 = "හෙලෝ";
String s3 = "hello";

System.out.println(s1.equals(s2)); // Output: true
System.out.println(s1.equals(s3)); // Output: false
System.out.println(s1.equalsIgnoreCase(s3)); // Output: true

5. contains(CharSequence s)

String එකක දීපු character sequence එකක් තියෙනවද කියලා බලනවා.

String message = "මම Java ඉගෙන ගන්නවා.";
System.out.println(message.contains("Java")); // Output: true
System.out.println(message.contains("Python")); // Output: false

6. startsWith(String prefix) / endsWith(String suffix)

String එකක් දීපු prefix එකකින් පටන් ගන්නවද, නැත්නම් suffix එකකින් ඉවර වෙනවද කියලා බලනවා.

String filename = "document.pdf";
System.out.println(filename.startsWith("doc")); // Output: true
System.out.println(filename.endsWith("pdf")); // Output: true

7. replace(char oldChar, char newChar) / replace(CharSequence target, CharSequence replacement)

String එකක තියෙන characters හෝ substrings වෙනත් characters/substrings වලින් replace කරන්න පාවිච්චි කරනවා.

String original = "වැරදි වැකිය.";
String corrected = original.replace('ව', 'ස'); // corrected = "සැරදි සැකිය."
String fixed = original.replace("වැරදි", "නිවැරදි"); // fixed = "නිවැරදි වැකිය."
System.out.println("නිවැරදි කළේ: " + fixed);

8. trim()

String එකක ඉස්සරහින් සහ පස්සෙන් තියෙන white spaces (හිස්තැන්) අයින් කරන්න මේක පාවිච්චි කරනවා.

String messy = "  හලෝ ලෝකය!   ";
String clean = messy.trim(); // clean = "හලෝ ලෝකය!"
System.out.println("පිරිසිදු කළේ: '" + clean + "'");

9. toUpperCase() / toLowerCase()

String එකක තියෙන අකුරු capital (uppercase) හෝ small (lowercase) කරන්න පාවිච්චි කරනවා.

String mixed = "JaVa PrOgRaMmInG";
System.out.println(mixed.toUpperCase()); // Output: JAVA PROGRAMMING
System.out.println(mixed.toLowerCase()); // Output: java programming

10. split(String regex)

String එකක් දීපු delimiter (නැත්නම් regular expression) එකක් අනුව කෑලි කෑලි වලට කඩලා String array එකක් විදිහට return කරනවා.

String csvData = "නම,වයස,නගරය";
String[] parts = csvData.split(","); // parts = {"නම", "වයස", "නගරය"}

for (String part : parts) {
    System.out.println(part);
}

String එකට String එකක් එකතු කිරීම – Concatenation

Strings එකට එකතු කරන එකට අපි කියන්නේ concatenation කියලා. මේකට ක්‍රම කීපයක් තියෙනවා.

1. + Operator

මේක තමයි Strings එකතු කරන්න තියෙන පහසුම ක්‍රමය.

String firstName = "අරුණ";
String lastName = " පෙරේරා";
String fullName = firstName + lastName; // fullName = "අරුණ පෙරේරා"
System.out.println(fullName);

හැබැයි, ඔයා Strings ගොඩක් එකතු කරන්න යනවා නම්, + operator එකෙන් හැම වෙලේම අලුත් String object එකක් හැදෙන නිසා performance wise එච්චර හොඳ නෑ. ගොඩක් Strings එකතු කරනකොට මේක memory එකටයි, processor එකටයි බරක් වෙන්න පුළුවන්.

2. concat() Method

concat() Method එකත් + operator එක වගේම තමයි. මේකෙන් එක String එකකට තව String එකක් එකතු කරන්න පුළුවන්.

String greeting = "සුභ ";
String time = "උදෑසනක්!";
String fullGreeting = greeting.concat(time); // fullGreeting = "සුභ උදෑසනක්!"
System.out.println(fullGreeting);

concat() Method එකත් + operator එක වගේම අලුත් String object එකක් return කරනවා. ඒ නිසා ගොඩක් concatenation operations වලට මේකත් එච්චර සුදුසු නෑ.

3. StringBuilder සහ StringBuffer

අපිට Strings ගොඩක් එක දිගට එකතු කරන්න අවශ්‍ය නම්, StringBuilder නැත්නම් StringBuffer class එක පාවිච්චි කරන එක තමයි හොඳම ක්‍රමය. මේ දෙකම mutable (වෙනස් කළ හැකි) character sequences maintain කරනවා. ඒ කියන්නේ මේවායේ තියෙන content එක කෙලින්ම වෙනස් කරන්න පුළුවන්. අලුතින් object හදන්න ඕන වෙන්නේ නෑ.

• StringBuilder: මේක thread-safe නෑ (synchronize කරලා නෑ). ඒ නිසා single-threaded environment එකක නම් වේගවත්.
• StringBuffer: මේක thread-safe (synchronize කරලා තියෙන්නේ). ඒ නිසා multi-threaded environment එකකදී ආරක්ෂිතයි. හැබැයි StringBuilder එකට වඩා ටිකක් වේගය අඩුයි.

උදාහරණයක් බලමු:

StringBuilder sb = new StringBuilder();
sb.append("ආයුබෝවන්");
sb.append(" ");
sb.append("ශ්‍රී");
sb.append(" ");
sb.append("ලංකා!");

String finalString = sb.toString(); // finalString = "ආයුබෝවන් ශ්‍රී ලංකා!"
System.out.println(finalString);

දැන් ඔයාලට පැහැදිලි ඇති Strings concatenate කරනකොට ගොඩක් Operations තියෙනවා නම් StringBuilder/StringBuffer පාවිච්චි කරන එක කොච්චර වැදගත්ද කියලා.

අවසන් වශයෙන්

ඉතින් යාලුවනේ, අද අපි Java Strings ගැන ගොඩක් දේවල් ඉගෙන ගත්තා. String එකක් කියන්නේ මොකක්ද, ඒකේ Immutability එක කියන්නේ මොකක්ද, ඒකේ තියෙන වැදගත් Methods මොනවද, සහ Strings එකතු කරන්නේ කොහොමද වගේ දේවල් ඔයාලට දැන් පැහැදිලි ඇති.

මේ Concepts ඔයාලගේ දෛනික coding වලට අනිවාර්යයෙන්ම ගොඩක් ප්‍රයෝජනවත් වෙයි. මතක තියාගන්න, Programming කියන්නේ Practice කරන තරමට දියුණු වෙන දෙයක්. ඒ නිසා අද ඉගෙන ගත්ත දේවල් ඔයාලගේ Project වලදී පාවිච්චි කරලා බලන්න. Strings එක්ක වැඩ කරනකොට මොනවා හරි ප්‍රශ්නයක් ආවොත්, ඒකට Stack Overflow, Java documentation වගේ resources පාවිච්චි කරන්න අමතක කරන්න එපා. ඒකත් ඉගෙනීමේ කොටසක්.

මේ Blog Post එක ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් comment කරන්න. අපි ඊළඟ Blog Post එකෙන් හමුවෙමු! Stay tuned for more interesting topics!