Java String Best Practices - Part 2

අද අපි කතා කරන්න යන්නෙ මගේ පලවෙනි පොස්ට් එකේම දිගුවක්. ඒ කියන්නෙ Spring Best Practice වල දෙවෙනි කොටස. 

ඔයාලට මතක ඇති මගේ පලවෙනි පොස්ට් එකේ මම කරුණු 6ක් ගැන කිව්ව. කට්ටියට මතක නැත්තන් ඒ ටික ආපහු පහලින් දාන්නම් මම. 

1. Strings දෙකක් එකතු කරන්න තියෙනවා නම් + operator වෙනුවට StringBuilder හරි StringBuffer හරි පාවිච්චි කරන්න. 
2. Strings දෙකක් සමානද කියල බලන්න තියෙනවා නම් == operator එක වෙනුවට equals() method එක පාවිච්චි කරන්න. 
3. Strings දෙකක් සමානද කියල බලන්න equals() method එක පාවිච්චි කරනවා නම්, අපි දන්න constant string එකකට දාන්න, නොදන්න variable එකකට පාවිච්චි කරන්න එපා. 
4. පුළුවන් හැම වෙලාවකම if else-if නැතුව switch-case පාවිච්චි කරන්න බලන්න, ඒ වගේම ඒ තැන් වල toString() වෙනුවට String.valueOf() පාවිච්චි කරන්න බලන්න. 
5. String එකක් හදනකොට new keyword එකෙන් Object එකක් හදන්නේ නැතුව literls("") විදියටම හදන්න. 
6. String එකක null check එකක් වගේ කරන්න තියෙනවා නම් StringUtils එකේ තියෙන methods පාවිච්චි කරන්න. 

ඒ කරුණු 6න් පලවෙනි කරුණ අපි පලවෙනි පොස්ට් එකේ කතා කල.එතකොට අද අපිට තියෙන්නෙ දෙවෙනි කරුණ ගැන කතා කරන්න.

හරි අපි වැඩේ පටන් අරන් යමු.

2.Strings දෙකක් සමානද කියල බලන්න තියෙනවා නම් == operator එක වෙනුවට equals() method එක පාවිච්චි කරන්න. 

මේ කොටසෙදි අපි බලන්න යන්නෙ Strings දෙකක් සමානද කියල බලන්න තියෙනවා නම් == operator එක වෙනුවට equals() method එක පාවිච්චි කරන්න ඕන කියන්නේ ඇයි කියන කාරණාව ගැනයි.

ඊට කලින් අපි බලමු කොහොමද String එකක් හදන්නේ කියල. String එකක් හදන්න පුළුවන් විදි දෙකක් තියෙනව.

1. By string literal : double quotes ඇතුලේ String එකක් ලියල ඒක String reference එකකට assign කරන්න පුලවන්(eg :- String myString = "TopJava";).
2. By new keyword : new keyword එක use කරල String එකක් හදන්නත් පුළුවන්. (eg :- String myString = new String("TopJava");)

මෙහෙම Strings හදනකොට මේවා හැදෙන්නෙ කොහෙද.පලෙවෙනි වර්ගයෙ ඒව හැදෙන්නෙ Java Heap එකේ තියෙන String Pool එකේ. දෙවෙනි වර්ගයෙ ඒවා හැදෙන්නෙ Java Heap Memory එකේ. හරියට මෙන්න මේ පහල පින්තූරේ තියෙනව වගේ.

මේ පින්තූරේ හරියට බැලුවොත් ඔයාලට පේන්න ඕන පොඩි දේවල් ටිකක් තියෙනව.
new keyword එක use කරලා TopJava කියල String දෙකක් හදල තියෙනව. ඒ වගේම එහෙම String දෙකක් Heap Memory එකෙත් හැදිල තියෙනව. new keyword එක use කරපු නිසා මෙයා කොහොමත්ඒ අලුතෙන්ම Object දෙකක් හදාගන්නව. quotes use කරල TopJava කියල str1 සහ str2 කියල String දෙකක් හදල තියෙනව.හැබැයි String Pool එකේ හැදිල තියෙන්නෙ TopJava කියල String එකයි. 

ඇයි එහෙම උනේ. මේක තමා String Pool වල තියෙන විශේෂත්වය. 

str1 කියන reference එක තියෙන TopJava String එක තමා අපි ඉස්සෙල්ලම හදල තියෙන්නෙ. අපි quotes use කරල String එක හදන්න යන නිසා මෙයා යන්නේ කෙලින්ම String Pool එකට. ගිහින් බලනව Topjava කියල String එකක් String Pool එකේ තියෙනවද කියල. එහෙම එකක් දැනට නෑනෙ. ඒක නිසා එයා Topjava කියල String එකක් String Pool එකේ හදාගන්නව. ඊළගට අපි යනව str2 කියන reference එක තියෙන TopJava කියල  තව String එකක් හදන්න. අන්න දැන් තමා වැඩේ. දෙවෙනි එක හදන්න යනකොට මෙයා බලනව TopJava කියල String එකක් දැනටමත් String Pool එකේ තියෙනවද කියල.ඔව් දැනටමත් එහෙම එකක් තියෙනව කලින් හැදිල.එහෙම වෙලාවට මෙයා අලුතෙන් TopJava කියල String එකක් හදන්න යන්නෙ නෑ. මෙයා කරන්නෙ කලින් හදපු TopJava String එකටම str2 කියල reference එක දාගන්නව. 

හරි දැන් අපි පොඩි backgraound එකක් හදාගත්ත වැඩේට.

දැන් අපි == සහ equals() දාල පොඩි code කෑල්ලක් ලියල බලමු.

public class CheckStringsEquality {
 public static void main(String[] args) {

  String str1 = "TopJava";
  String str2 = "TopJava";

  String str3 = new String("TopJava");
  String str4 = new String("TopJava");
  String str5 = new String("Dog");

  System.out.println("1."+" == operator result for str1 and str2 : " + (str1 == str2));
  System.out.println("2."+" == operator result for str3 and str4 : " + (str3 == str4));
  System.out.println("3."+" == operator result for str1 and str3 : " + (str1 == str3));
  System.out.println("4."+" equals() method result for str1 and str2 : " + str1.equals(str2));
  System.out.println("5."+" equals() method result for str3 and str4 : " + str3.equals(str4));
  System.out.println("6."+" equals() method result for str1 and str3 : " + str1.equals(str3));
  System.out.println("7."+" equals() method result for str4 and str5 : " + str4.equals(str5));
 }
}

අපි බලමු මේවයේ outputs මොන වගේ වෙයිද කියල.

1. == operator result for str1 and str2 : true
2. == operator result for str3 and str4 : false
3. == operator result for str1 and str3 : false
4. equals() method result for str1 and str2 : true
5. equals() method result for str3 and str4 : true
6. equals() method result for str1 and str3 : true
7. equals() method result for str4 and str5 : false 

අපි මේ outputs එකින් එක අරන් බලමු.
output number 1 එකේ කරලා තියෙන්නේ str1 සහ str2 දෙක සමානද කියල බලන එක. output එක ඇවිල්ල තියෙන්නෙ true කියල. බැලූ බැල්මට කාටහරි කියන්න පුළුවන් ඔව් ඒක ඇත්තනෙ ඉතින් දෙකේම තියෙන්නෙ එකම String එකනෙ කියල,ඒ කියන්නෙ දෙකේම value එක TopJava නිසා output එක true ඇවිල්ල තියෙනව කියල..ඒත් ඇත්තටම මෙතනදී output එක true කියල ඇවිල්ල තියෙන්නෙ ඒක නිසාමද. ඒක එහෙම නම් ,ඇයි output number 2 එකේ output එක false කියල ඇවිල්ල තියෙන්නෙ. ඒ දෙකෙත් value එක සමානයි.එහෙනම් ඒකෙ output එකත් true කියල එන්න ඕන.

හරි ඔය ප්‍රශ්නෙ අපිට විසදගන්න වෙන්නෙ මෙහෙම.මම උඩ දාල තියෙන iamge එක ආපහු පොඩ්ඩක් බලන්න. ඔයාලට පේන්න ඕන str1 සහ str2 දෙකම refer කරන්නෙ එකම TopJava String Object එක. හොදට මතක තියාගන්න == operator එක හැම වෙලාවෙම බලන්නෙ අපි check කරන varibale දෙක refer කරන්නෙ, Heap එකේ එකම location එකක තියෙන String object එකක්ද කියන එකයි. නැතුව එයා බලන්නෙ නෑ ඒ String variable දෙකේ value එක සමානද කියල. 

දැන් ඔයාලට තේරෙන්න ඕන ඇයි output number 3 එකේ output එක false ආවෙ කියල. str1 කියන්නෙ String Pool එක ඇතුලෙ තියෙන Object එකක්. str3 කියන්නෙ new keyword එක use කරල හදල තියෙන Heap memory එකේ වෙනම ලොකතිඔන් එකක තියෙන object එකක්. ඒ කියන්නේ str1 සහ str3 refer කරන්නෙ වෙනම location දෙකක තියෙන object දෙකක්. ඒක නිසා තමා output එක false කියල ආවෙ. 

එතකොට output number 2 එකේ මොකක්ද වෙලා තියෙන්නේ. මම කලිනුත් කිව්වා new keyword එක use කරලා String හදනකොට එයා හැම වෙලාවෙම අලුත් Object එකක් තමා හදන්නේ. str3 සහ str4 කියන්නෙත් Heap memory එකේ වෙනම location දෙකක හැදුනු වෙනමම object දෙකක් refer කරන variabel දෙකක්. ඒක නිසා output එක false කියල ඇවිල්ල තියෙනව.

හ්ම් output number 4 එකේ මොකද වෙලා තියෙන්නෙ.මොකක්ද මේ equals() method එක. equals() method එක ගැන ටිකක් deep අපි පස්සෙ කතා කරමු. සරලව කිව්වොත් equals() method එක අපිට use කරන්න පුළුවන් String දෙකක value එක සමානද කියල බලාගන්න. 

එතකොට ඔයාලට පේන්න ඕන output number 4 එකේ String දෙක check කරල තියෙන්නෙ str1.equals(str2) කියල. එහෙම තමා equals() method එක call කරන්නෙ. ඒ method ඒකෙන් boolean value එකක් (true or false) return කරනව String දෙකේ values check කරල. values සමානයි නම් true return කරනව. values සමාන නැත්තන් false return කරනව. str1 සහ str2 දෙකේම value එක TopJava නිසා output එක true කියල ඇවිල්ල තියෙනව.

එහෙනම් ඒ විදියටම output number 5 එකෙත් equals() method එකෙන් values check කලාම output එක true කියල ඇවිල්ල තියෙනව. output number 6 එකත් ඒ වගේමයි,වෙනසක් නෑ. 

output number 7 එකේ පොඩි වෙනසක් තියෙනව ඔයාලට පේනවද. ඒකෙ check කරල තියෙන්නෙ str4 සහ str5. str4 එකේ value එක TopJava , str5 එකේ value එක Dog. එතකොට ඒ දෙකේම values සමාන නෑ කියල ඔයාලට පේනව. ඒකනිසා output number 7 එකේ output එක false කියල ඇවිල්ල තියෙනව.

මේ ටික හොද කල්පනාවෙන් ඔලුවට දාගත්ත නම් දැන් ඔයාලට තේරෙන්න ඕන ඇයි String දෙකක values සමානද කියල බලන්න තියෙන වෙලාවක == operator නැතුව equals() method එක use කරන්න කියන්නෙ කියල. 

ඇත්තටම කිව්වොත් මේ පොස්ට් එකේ කියන්න හිටපු කරුණු ටික ඔය ටික තමා. ඒත් මේ ටිකත් කියල හිටියනම් කියල හිතුන.

මෙන්න මේ ටිකත් පොඩ්ඩක් බලන්න.

ඔය උඩ image එකේ තියෙන ටික දාල පොඩි code කෑල්ලක් ලිව්ව මම. ඒකෙ outputs ටිකත් බලමු.

public class CheckStringsEquality2 {
    public static void main(String[] args) {
        String a = "one";
        String b = "one";
        String c = "ONE";

        String d = new String("one");

        System.out.println("1."+" == operator result for a and b : " + (a == b));
        System.out.println("2."+" == operator result for a and c : " + (a == c));
        System.out.println("4."+" equals() method result for a and b : " + a.equals(b));
        System.out.println("5."+" equals() method result for a and c : " + a.equalsIgnoreCase(c));
        System.out.println("2."+" == operator result for a and d : " + (a == d));
        System.out.println("6."+" equals() method result for a and d : " + a.equals(d));
    }
}

1. == operator result for a and b : true
2. == operator result for a and c : false
4. equals() method result for a and b : true
5. equals() method result for a and c : true
2. == operator result for a and d : false
6. equals() method result for a and d : true

output number 1 එක නම් අපි කලින් කතා කරල තියෙනව. ඒක ඔයාලට දැන් පුළුවන්. output number 2 එකේ හොදට බලන්න string a ගෙ තියෙන්නෙ one කියල string c ගෙ තියෙන්නෙ ONE කියල. ඒ කියන්නෙ එතනදි වෙනස් String object දෙකක් හැදිල තියෙනව.output number 3 එකත් ඔයාල දන්නව. output number 4 එකේ පොඩි වෙනසක් තියෙනව නේද. එතන මොකක්ද කරලා තියෙන්නෙ.බලන්න එතනදි String දෙකේ values සමානද කියල බලන්න කතා කරලා තියෙන්නෙ a.equalsIgnoreCase(c) කියල method එකක් නේද. මේකත් equals() method එක වගේම තමා.මේ මෙතොඩ් එකේදි කරලා තියෙන්නෙත් String දෙකේ values සමානද කියල බලන එක තමා, වෙනසකට තියෙන්නේ String දෙකේ case sensitive එක ignore කරල. ඒ කියන්නෙ මෙයා one කියන එකයි ONE කියන එකයි සමානයි කියල තමයි consider කරන්නෙ. අනිත් outputs ටිකත් අපි කලින් කතා කරපු ටිකමයි.

මෙන්න මේ image එක ගැනත් පොඩ්ඩක් කතා කරලම අදට වැඩේ නතර කරමු.

මේකටත් පොඩි code කෑල්ලක් ලියල බලමු මොකද වෙන්නේ කියල.

public class CheckStringsEquality3 {
    public static void main(String[] args) {
        String string1 = "Java";
        String string2 = string1.intern();

        String string3 = new String("Java").intern();

        System.out.println("1."+" == operator result for string1 and string2 : " + (string1 == string2));
        System.out.println("2."+" == operator result for string1 and string3 : " + (string1 == string3));
        System.out.println("3."+" equals() method result for string1 and string2 : " + string1.equals(string2));
    }
}

1. == operator result for string1 and string2 : true
2. == operator result for string1 and string3 : true
3. equals() method result for string1 and string2 : true

මේ example එකේ බලන්න intern() කියල method එකකට call කරල තියෙනව. intern() method එකෙන් කරන්නෙ Heap memory එකේ තියෙන String Object එකේ සර්ව සම්පුර්ණ copy එකක් හදල, ඒක String Pool එකට ගිහින් දාන එක. එහෙම නැත්තන් දැනටමත් String Pool එකේ ජාතියෙ String එකක් තියෙනව නම් same memory location එක share කරගන්න එක. ඒකයි මෙතන string3 reference එක new keyword එක use කරල අලුත් object එකක් හැදුවත් එයා String pool එකේ තියෙන string1 කියන reference එක තියෙන Java object එකම refer කරනව. 

හරි අදට ඇති. අදහස් යෝජනා චෝදනා කොමෙන්ටු වල අමුණන්න. ජය වේවා!