Java String Best Practices - Part 1

අපේ පලවෙනි පොස්ට් එකෙන් මම කතා කරන්න හදන්නේ String පාවිච්චි කරන කොට අපි පොඩ්ඩක් දැනගෙන ඉන්න ඕන දේවල් ටිකක් ගැනයි. Interview වලදිත් මේව ගැන අහන්න පුළුවන්. මේ ටික හරියට ඔලුවට දාගන්න. ඔයාල වැඩ කරන project එකට ඵලදයී විදියට මේ ටික යොදාගන්න බලන්න. 

මම ඉස්සෙල්ලම කරුණු 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 පාවිච්චි කරන්න. 

හරි දැන් අපි උඩ කියපු points එකින් එක අරන් බලමු.

1. Strings දෙකක් එකතු කරන්න තියෙනවා නම් + operator වෙනුවට StringBuilder හරි StringBuffer හරි පාවිච්චි කරන්න.

ඔයාල දන්නවා String concat කරනවා කියන්නේ String දෙකක් එකට එකතු කරනවා කියන එක කියල. මේක සාමාන්‍යයෙන් numbers දෙකක් එකතු කරනව වගේ නෙමේ. සරලව කිව්වොත් මේ වගේ දෙයක් තමා වෙන්නේ. 

String sun = "Sun";
String down = "Down";
String space = " ";

String sunDown = sun + space + down; ->  Sun Down

Code

Output

හරි දැන් ඔයාල දන්නවා මොකක්ද concatenation කියන්නේ කියල. දැන් අපි බලමු ඇයි අපිට කියන්නේ කලින් කරපු විදියට String concat කරන්නේ නැතුව StringBuilder හරි StringBuffer හරි use කරන්න කියල.

මෙතනදි එකක් කියන්ට ඕන StringBuffer වැඩ කරන්නෙත් StringBuilder වැඩ කරන විදියටම තම , එකම method එකක් තමා දෙකේම use කරලා තියෙන්නේ concat වලට. පොඩි වෙනසකට තියෙන්නේ මේ දෙක use කරන context එකේ. StringBuffer, synchronized. ඒක නිසා multi-threading context එකක StringBuffer පාවිච්චි කල යුතුයි.මේ කියපු ටික තේරෙන්නේ නැත්තන් වැඩිය හිතන්න යන්න එපා. මේවා ගැන පස්සේ කතා කරනවා.

අපි පොඩි code කෑල්ලක් ලියල බලමු String, StringBuffer, StringBuilder යන තුනෙන් කාගෙද performance වැඩි කියල බලන්න.

Code 

public void calculatePerformance(){
    String str = "";
    long startTime = System.nanoTime();
    for(int i=0 ; i < 10 ; i++) {
        str = str + i;
    }
    long endTime = System.nanoTime();
    System.out.println(String.format("String operation with " +
            "operator took [%d] nano seconds",(endTime-startTime)));

    StringBuilder builder = new StringBuilder();
    startTime = System.nanoTime();
    for(int i=0;i<10;i++) {
        builder.append(i);
    }
    endTime = System.nanoTime();
    System.out.println(String.format("String opetation with " +
            "StringBuilder took [%d] nano seconds",(endTime-startTime)));

    StringBuffer strBuffer = new StringBuffer();
    startTime = System.nanoTime();
    for(int i=0;i<10;i++) {
        strBuffer.append(i);
    }
    endTime = System.nanoTime();
    System.out.println(String.format("String opetation with " +
            "StringBuffer took [%d] nano seconds",(endTime-startTime)));
}

Output 

String operation with operator took [154800] nano seconds

String opetation with StringBuilder took [3500] nano seconds

String opetation with StringBuffer took [9500] nano seconds

ඇවිල්ල තියෙන results බලපුවම තේරෙනව String concat කරද්දි + operator එකට වඩා වේගයෙන් StringBuilder සහ StringBuffer වැඩ කරල තියෙනව කියල.

ඔයාල හරියට බැලුවොත් මෙතනදි ඔයාලට ප්‍රශ්ණ දෙකක් එන්න ඕන.

1. String, StringBuilder, StringBuffer තුනට වෙනස්ම අගයන් තුනක් තියෙන්නේ. ඒ කියන්නේ String වලට වඩා StringBuffer අඩුයි ඊටත් වඩා StringBuilder අඩුයි.
2. කොහොමද එහෙම වෙන්නෙ.

මම මෙතැනදී String එක පැත්තකට දානව අනිත් පැත්තෙ ඉන්නේ StringBuilder සහ StringBuffer.අපි ඉස්සෙල්ලම බලමු String වලට වඩා අනිත් දෙකේ time එක අඩු උනේ කියල.

අපි මේක සරලව බේරගන්න බලමු. 

Java වල String Objects හැදෙන්නේ immutable විදියට. මොකක්ද මේ immutabale කියන්නේ. immutable කියන්නේ අපි String එකක් හදනකොට ඒක හැදෙන්නේ Constant(නියතයක්) විදියට.ඒ කියන්නේ ඒක හැදුවට පස්සේ එයාගෙ valuues වෙනස් කරන්න බෑ.එතකොට අපි String concat කරනකොට එයා කරන්නේ පරණ String  Object එක තියෙද්දිම අලුත් එකක් හදාගන්නව. එතකොට අපි දිගට දිගට String concat කරගෙන ගියොත් දේවල් දෙකක් වෙන්න පුළුවන්. එකක් තමා Heap memory එක වැඩිපුර use වෙනවා මොකද හැමවෙලේම අලුත් String එකක් memory එකේ හැදෙන නිසා. අනිත් එක අලුතෙන් String හද හද ඒවා assign කර කර යන්න ගියාම time එකත් වැඩිපුර යනව. එක නිසා තම අපේ result වල String වලට ගොඩක් ලොකු time එකක් ගිහින් තියෙන්නේ අනිත් දෙකත් එක්ක බලද්දී.

StringBuilder සහ StringBuffer හැදෙන්නේ mutable විදියට. එතකොට මෙයාල අලුතෙන් Objects හදන්නෙ නෑ. තියෙන එකම update කරන් යනව. ඒක නිසා තමා මෙයාල String වලට වඩා ඉක්මන් වෙන්නෙ. තාමත් එක ප්‍රශ්ණයක් ඉතුරුයි. කොහොමද StringBuilder StringBuffer ට වඩා අඩුකාලයකින් වැඩේ කලේ. 

ඒක වෙන්නේ මෙහෙමයි. StringBuffer වැඩ කරන්නේ Syncronized විදියට. ඒ කියන්නේ එයා එකම thread එකක තමා වැඩ කරන්නෙ.ඒක නිසා අපිට කියන්න පුළුවන් StringBuffer thread-safe කියල.StringBuilder වැඩ කරන්නේ Syncronized විදියට නෙමේ. ඒ කියන්නේ එයා thread කීපයක වැඩ කරන්න පුළුවන්.ඒක නිසා එයා thread-safe නෑ. StringBuilder syncronize නොවී  StringBuffer syncronize විදියට වැඩ කරන නිසා තමා StringBuilder, StringBuffer ට වඩා fast වෙන්නෙ. මෙතැනදී තව එකක් කියන්න ඕන.අපි multi-thread context එකක වැඩ කරනවනම් StringBuffer use කරන්න මතක තියාගන්න.

හරි එහෙනම් අද පාඩම අපි මෙතනින් නවත්තමු. ඉතුරු ටික මගේ ඊලග පොස්ට් එකෙන් මම අරන් එන්නම්. මේ ටිකත් කියන්න ඕන, මගේ අරමුණ උනේ String best practice ගැන පොඩි දේවල් ටිකක් කතා කරන එකයි.මම කරුණු වල ගොඩක් deep ගියේ නෑ.උඩ කියල තියෙන සියලු කරුණු ගැන සංවාද කරමු,වෙනස් වෙන්න ඕන ඒවා තියෙනව නම් කොමෙන්ටු අමුණන්න.

මේ blog post එකේ මම කියපු ඒවගේ demo එකක් කරල තියෙනව පහල වීඩියෝ එකේ. එකත් පොඩ්ඩක් බලන්න.

Java String Best Practices Part 01