Java String Best Practices - Part 3

අද මම මේ post එකෙන් කතා කරන්න යන්නෙ Java String Best Practices - Part 1 එකේ කතා කරපු Java String වල Best Practices වල තුන්වෙනි point එක ගැන. ඔයාලට ඒ points ටික මතක නැත්තන් මම මෙතන ඒ points ටික ආපහු දාන්නම්. 

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 පාවිච්චි කරන්න. 

අද අපි කතා කරන්න යන්නේ ඒකෙ තුන්වෙනි point එක ගැනයි.

3. Strings දෙකක් සමානද කියල බලන්න equals() method එක පාවිච්චි කරනවා නම්, අපි දන්න constant string එකකට දාන්න, නොදන්න variable එකකට පාවිච්චි කරන්න එපා.

Java String Best Practices - Part 2 පොස්ට් එකේ ඔයාලට මතක ඇති මම කියල දුන්න equals() method එක හරියට පාවිච්චි කරන්නෙ කොහොමද කියල. ඔයාල දන්නව equals() method එක අපි කොහොමත් use කරන්නේ String දෙකක value එක සමානද කියල බලන්න කියල. 

එහෙනම් මොකක්ද මේ කියන කතාව. 

මෙතනදි කියන්නේ මේ වගෙ කතාවක්. අපි String දෙකක් සමානද කියල බලන්න equals() method එක පාවිච්චි කරන්නේ මෙන්න මේ වගේ pattern එකකටනෙ. String1.equals(String2)

ඔයාල මේ pattern එකට equals() method එක පාවිච්චි කරනව නම්, String1 කියන String එක ඔයා හරියටම value එක දන්න String එකක් වෙන්න ඕන. String2 එකේ value එක ඔයා දන්නේ නැති වෙන්න පුළුවන්,ඒකට කමක් නෑ.

එහෙම කියන්නෙ මොකද දන්නවද, හිතන්න String1 කියන්නෙ ඔයා value එක දන්න String එකක්. ඒක null වෙන්න බෑ. ඒත් හිතන්න String2 කියන්නෙ ඔයා දන්නෙ නැති value එකක් එන්න පුළුවන් String එකක්.ඒක null වෙන්නත් පුලුවන්. ඔයා null එකකට equals() method එක පාවිච්චි කරපු ගමන් NullPointerException එකක් පනින්න පුළුවන්.

ඔයාලට මේ කියපු ටික තව ටිකක් හොදට තේරෙන්න අපි පොඩි example එකක් බලමු.

හිතන්න ඔයාට task එකක් තියෙනවා order එකක් process කරන්න. ඊට කලින් ඔයා payment එක process කරන්න ඕන. payment transaction එකේ status එක check කරලා තමා order එකේ ඉතුරු ටික process කරන්න තියෙන්නෙ.  එතකොට ඔයා ගාව තියෙනවා transaction එකට එන්න පුළුවන් status list එකක්.ඔයා ඒ ටික constant ටිකකට assign කරගෙන ඉන්නවා payment API එකේ එන status එකත් එක්ක check කරලා බලන්න.

අපි මේ වගේ transaction status list එකක් තියාගෙන ඉන්නවා කියල හිතන්න.

private static final String TRANSACTION_SUBMITTED = "TRANSACTION_SUBMITTED";
private static final String TRANSACTION_PROCESSING = "TRANSACTION_PROCESSING";
private static final String TRANSACTION_SUCCESSFUL = "TRANSACTION_SUCCESSFUL";

අපි ඉස්සෙල්ලම බලමු අපිට මෙතන වරදින්නේ කොහොමද කියල.

මම ලියනවා doPayment() කියල method එකක්. මේ method එක තමා ඔයාල payment API එකට call කරලා response එක ගන්න method එක. මම දැනට මේ method එකෙන් transactionStatus එක null value එකක් return කරනවා. මෙන්න මේ වගේ.

public static String doPayment(){
    String transactionStatus = null;
    return transactionStatus;
}

ඊළගට මම ඔය value එක pass කරනවා transaction status එක check කරන method එකට.එකේ නම දාල තියෙන්නෙත් checkTransactionStatusIncorrectWay මේ විදියට.

private static void checkTransactionStatusIncorrectWay(String txnStatus) {
    try {
        if (txnStatus.equals(TRANSACTION_SUCCESSFUL)){
            System.out.println("Transaction Successful");
        }
        else {
            System.out.println("Transaction Failed");
        }
    }
    catch (Exception e){
        System.out.println("Exception occurred");
        e.printStackTrace();
    }
}

බලන්න මෙතන මම txnStatus.equals(TRANSACTION_SUCCESSFUL) මෙන්න මෙහෙම තමා පාවිච්චි කරල තියෙන්නේ. එතකොට ඔයාලට දැන් පේනවද txnStatus value එක null. අපි null value එකකට තමා equals() method එක දාල තියෙන්නෙ. මොකද වෙන්නේ කියල බලන්න මේක run කරලම බලමුද.

Exception occurred

java.lang.NullPointerException

at com.teciezone.CheckEqualsOnKnown.checkTransactionStatusIncorrectWay(CheckEqualsOnKnown.java:29)

at com.teciezone.CheckEqualsOnKnown.main(CheckEqualsOnKnown.java:17)

ඔන්න පේනවද output එක. NullPointerException එකක් තමා ඇවිල්ල තියෙන්නේ.

දැන් අපි මේක හරි විදියට කරලා බලමු.

public static void checkTransactionStatusCorrectWay(String txnStatus){

    if (TRANSACTION_SUCCESSFUL.equals(txnStatus)){
        System.out.println("Transaction Successful");
    }
    else {
        System.out.println("Transaction Failed");
    }
}

මෙතන බලන්න මම variable දෙක මාරු කරලා equals() method එකට දැම්මා.

මේකෙත් output එක අරන් බලමුද.

දැන් ඔයාලට පේනවද මෙතනදී exception එක පැනල නෑ. ඒ කියන්නේ අපේ වැඩේ හරි. එහෙනම් දැන් ඔයාලට තේරෙන්න ඕන හරි විදියට equals() method එක පාවිච්චි කරන්නේ කොහොමද කියල. අපි value එක හරියටම දන්නා String එකකට තමා equals() method එක දාන්න ඕන.

මේ කියල තියෙන දේ හරියට තේරුනේ නැත්තන් පහල තියෙන වීඩියෝ එක බලන්න, මම එකේ demo එකකුත් කරලම පෙන්නනවා. එහනම් ඊලග පොස්ටුවෙන් හම්බෙමු,එතකන් ජය.