Java Null පරීක්ෂණ පැහැදිලි කිරීම: හොඳ පුරුදු, Optional, සහ ආරක්ෂිත කේතන තාක්ෂණ

හැඳින්වීම

Java හි වැඩසටහන් ලියන විට, null පරීක්ෂණ අත්‍යවශ්‍ය සහ ඉතා වැදගත් මාතෘකාවකි. විශේෂයෙන් ව්‍යාපාරික පද්ධති සහ විශාල පරිමාණ යෙදුම් වල, සංවර්ධකයන් අඩු වී ඇති හෝ ආරම්භ නොකළ දත්ත නිවැරදිව හසුරවිය යුතුය. null නිසි ලෙස හසුරවන්නේ නැති නම්, NullPointerException වැනි අනපේක්ෂිත දෝෂ ඇතිවිය හැකි අතර, ඒවා යෙදුමේ විශ්වාසනීයතාවය සහ නඩත්තුකිරීමේ හැකියාවට දැඩි බලපෑමක් කරයි.

“null පරීක්ෂණ අවශ්‍ය වන්නේ ඇයි?” සහ “null ආරක්ෂිතව කෙසේ හසුරවිය හැකිද?” වැනි ප්‍රශ්න නවකයින්ට පමණක් නොව, පළපුරුදු ඉංජිනේරුවන්ටද මුහුණ දීමට සිදුවන අභියෝග වේ. මෑත කාලයේ, Java 8 හි හඳුන්වා දුන් Optional පන්තිය වැනි null-ආරක්ෂිත නිර්මාණ ක්‍රමයන් ලබා ගත හැකි විකල්පයන් පුළුල් කර ඇත.

මෙම ලිපිය Java හි null හි මූලික කරුණු, පොදු පරීක්ෂණ ක්‍රම, වාස්තුක පරිසරයේ භාවිතා වන ප්‍රායෝගික තාක්ෂණ, සහ දෝෂ වැළැක්වීම සඳහා හොඳම පුරුදු පිළිබඳ සියල්ල පැහැදිලි කරයි. ඔබ Java නවකයෙක් වුවත්, හෝ දැනටමත් නිෂ්පාදන පරිසරයේ වැඩ කරමින් සිටියත්, මෙම මාර්ගෝපදේශය සම්පූර්ණ සහ ප්‍රයෝජනවත් දැනුමක් ලබා දේ.

null යනු කුමක්ද?

Java හි, null යනු වස්තු යොමුකිරීමක් කිසිදු උදාහරණයක් වෙත සම්බන්ධ නොවන බව පෙන්වන විශේෂ අගයක් වේ. සරලව කියනවා නම්, එය “කිසිවක් නොමැති” , “තවමත් අගයක් පවරා නොමැති” හෝ “යොමුකිරීම පවතින්නේ නැත” යන තත්ත්වයක් නිරූපණය කරයි. Java හි ඕනෑම වස්තු-වර්ගයේ විචල්‍යයක්, පළමුවෙන්ම ආරම්භ නොකළහොත්, null වෙන්න පුළුවන්.

උදාහරණයක් ලෙස, පහත පෙන්වා ඇති පරිදි වස්තු-වර්ගයේ විචල්‍යයක් ප්‍රකාශ කරන විට, එය මුලින්ම කිසිදු උදාහරණයක් වෙත පවරා නොමැත.

String name;
System.out.println(name); // Error: local variable name might not have been initialized

ඔබට null ස්පෂ්ටව පවරා ගැනීමටත් හැකිය:

String name = null;

null ලෙස සකස් කර ඇති විචල්‍යයක් මත ක්‍රමයක් කැඳවීමට හෝ ගුණාංගයක් ප්‍රවේශ කිරීමට උත්සාහ කළහොත්, NullPointerException එකක් සිදුවේ. මෙය Java හි සාමාන්‍යතම ක්‍රියාකාලීන දෝෂයන්ගෙන් එකකි.

null, හිස් පද (empty strings) සහ හිස් පද (blank strings) අතර වෙනස්කම්

null සාමාන්‍යයෙන් හිස් පද ("") හෝ හිස් පද (උදාහරණයක් ලෙස, " ") සමඟ ගැලපෙයි.

• null මතකයේ වස්තුවක් නොමැති බව පෙන්වන විශේෂ අගයක් නියෝජනය කරයි.
• Empty string (“”) දිග 0 වන, මතකයේ පවතින පද වස්තුවකි.
• Blank string (” “) එක් හෝ වැඩි සුන්‍ය අක්ෂර (whitespace) අඩංගු පදයක් වන අතර, එයද වස්තුවක් ලෙස පවතී.

සාරාංශයෙන්, null යනු “කිසිදු අගයක් පවතින්නේ නැත” යන අර්ථය දරයි, එත් "" සහ " " යනු “අගයක් පවතින නමුත් එහි අන්තර්ගතය හිස් හෝ සුන්‍ය අක්ෂර වලින් පිරී ඇත” යන අර්ථය දරයි.

null මඟින් ඇතිවන පොදු ගැටළු

null නිවැරදි නොවූ ලෙස හසුරවීම අනපේක්ෂිත ක්‍රියාකාලීන දෝෂයන්ට හේතු විය හැක. සාමාන්‍ය ගැටළු අතර:

• NullPointerException null යොමුකිරීමක් මත ක්‍රමයක් කැඳවීම හෝ ගුණාංගයක් ප්‍රවේශ කිරීමේදී සිදුවේ.
• Unintended control flow කොන්දේසි ප්‍රකාශනවල null පරීක්ෂණ අමතක කිරීමෙන් තර්කය මඟ හැරී යාමට, දෝෂ ඇති වීමට හේතු වේ.
• Business disruption due to missing data or exceptions දත්ත ගබඩා හෝ බාහිර API වලින් ලබා ගන්නා null අගයන් අනපේක්ෂිත පද්ධති හැසිරීමකට හේතු විය හැක.

null ශක්තිමත් වුවද, අනිසි භාවිතය තීව්‍ර ගැටළු ඇති කරයි.

මූලික null පරීක්ෂණ ක්‍රම

Java හි null පරීක්ෂා කිරීමට විවිධ ක්‍රම ඇත. මූලිකම ක්‍රමය සමානතාව (==) සහ අසමානතාව (!=) මෙහෙයුම් භාවිතා කිරීමයි. පහත පොදු රටා සහ ඒවායේ සැලකිලිමත් කරුණු දැක්වේ.

null පරීක්ෂණ සඳහා සමානතා මෙහෙයුම් භාවිතා කිරීම

if (obj == null) {
    // Processing when obj is null
}

if (obj != null) {
    // Processing when obj is not null
}

මෙම ක්‍රමය සරල හා වේගවත් වන අතර Java ව්‍යාපෘතිවල පුළුල් ලෙස භාවිතා වේ. කෙසේ වෙතත්, null පරීක්ෂණ නොකිරීම කේතයේ පසුබැසීමේදී NullPointerException එකක් ඇති කරයි, එබැවින් null-සම්භවිතා විචල්‍ය පරීක්ෂා කිරීම අත්‍යවශ්‍ය වේ.

Objects පන්තිය භාවිතා කිරීම

Java 7 සිට, java.util.Objects පන්තිය null පරීක්ෂණ සඳහා උපකාරක ක්‍රම ලබා දේ.

import java.util.Objects;

if (Objects.isNull(obj)) {
    // obj is null
}

if (Objects.nonNull(obj)) {
    // obj is not null
}

මෙම ක්‍රමය කියවීමට පහසුකම වැඩි කරයි, විශේෂයෙන් ස්ට්‍රීම් හෝ ලැම්බඩා ප්‍රකාශනවල භාවිතා කරන විට.

equals() භාවිතා කිරීමේ වැදගත් සටහන්

සාමාන්‍ය වැරදි එකක් වන්නේ equals() ක්‍රමය null විය හැකි විචල්‍යයක් මත කැඳවීමයි.

// Incorrect example
if (obj.equals("test")) {
    // processing
}

obj එක null නම්, මෙය NullPointerException එකක් දෝෂයක් දමයි.

ආරක්ෂිත ක්‍රමයක් වන්නේ literals හෝ null නොවන අගයක් මත equals() ක්‍රමය කැඳවීමයි.

// Correct example
if ("test".equals(obj)) {
    // processing when obj equals "test"
}

මෙම තාක්ෂණය Java හි පුළුල් ලෙස භාවිතා කරයි සහ ක්‍රියාකාලීන දෝෂ වලින් වැළකී සිටී.

Optional පන්තිය සමඟ null හසුරවීම

Optional පන්තිය Java 8 හි හඳුන්වා දී ඇති අතර, null සෘජුව භාවිතා නොකර අගයක් පවතිනවාද නැද්ද යන්න ආරක්ෂිත ලෙස නිරූපණය කරන ක්‍රමයක් ලබා දෙයි. එය කේතයේ කියවීමේ හැකියාව සහ ආරක්ෂාව විශාල ලෙස වැඩි කරයි.

Optional යනු කුමක්ද?

Optional යනු අගයක් පවතිනවාද නැද්ද යන්න පැහැදිලිව නිරූපණය කරන wrapper පන්තියකි. එහි අරමුණ null ගැන අවබෝධය ඇති කර ගැනීමට සහ ඉලක්ක කරමින් null භාවිතය වැළැක්වීමටයි.

Optional හි මූලික භාවිතය

Optional<String> name = Optional.of("Sagawa");
Optional<String> emptyName = Optional.ofNullable(null);

අගයන් ලබා ගැනීමට:

if (name.isPresent()) {
    System.out.println(name.get());
} else {
    System.out.println("Value does not exist");
}

ප්‍රයෝජනවත් Optional ක්‍රම

• orElse()

  String value = emptyName.orElse("Default Name");
  

• ifPresent()

  name.ifPresent(n -> System.out.println(n));
  

• map()

  Optional<Integer> nameLength = name.map(String::length);
  

• orElseThrow()

  String mustExist = name.orElseThrow(() -> new IllegalArgumentException("Value is required"));
  

Optional භාවිතා කිරීමේ හොඳ පුරුදු

• Optional ප්‍රධාන වශයෙන් ක්‍රම ප්‍රතිලාභ වර්ගයක් ලෙස භාවිතා කරන්න, ක්ෂේත්‍ර හෝ පරාමිතීන් සඳහා නොව.
• Optional ආපසු ලබා දීමෙන් අගයක් නොමැති වීමේ හැකියාව පැහැදිලි කරයි සහ කැඳවුම්කරුවන් විසින් පරීක්ෂා කිරීමට බල කරයි.
• අගය නියමිතව පවතින විට Optional භාවිතා නොකරන්න.
• Optional ස්වයංට null අගයක් පවරා ගැනීමෙන් වැළකී සිටින්න.

null පරීක්ෂණයේ හොඳ පුරුදු

ආචාරික Java සංවර්ධනයේ, සරලව null පරීක්ෂා කිරීම පමණක් ප්‍රමාණවත් නොවේ. null කෙසේ හසුරවයිද, වැළැක්වයිද යන්නද සමාන ලෙස වැදගත් වේ.

null පරීක්ෂණ සමඟ ආරක්ෂක වැඩසටහන්

ආරක්ෂක වැඩසටහන් යනු ඇතුළත් දත්ත අපේක්ෂා පරිදි නොවිය හැකි බව සලකා, දෝෂ වලින් පූර්ව වශයෙන් ආරක්ෂා කිරීමයි.

public void printName(String name) {
    if (name == null) {
        System.out.println("Name is not set");
        return;
    }
    System.out.println("Name: " + name);
}

හිස් එකතු කිරීම් හෝ පෙරනිමි අගයන් ආපසු ලබා දීම

null ආපසු ලබා දීම වෙනුවට, හිස් එකතු කිරීම් හෝ පෙරනිමි අගයන් ලබා දීමෙන් කැඳවුම්කරුගේ තර්කය සරල කරයි.

// Bad example
public List<String> getUserList() {
    return null;
}

// Good example
public List<String> getUserList() {
    return new ArrayList<>();
}

කේතනීති සකස් කිරීම

• ක්‍රම වලින් null ආපසු ලබා නොදෙන්න; හිස් එකතු කිරීම් හෝ Optional ආපසු ලබා දෙන්න.
• හැකි තරම් null පරාමිතීන් ලබා දීමෙන් වැළකී සිටින්න.
• ක්‍රම ආරම්භයේ null පරීක්ෂණ කරන්න.
• අදහස් කර ඇති null භාවිතය අදහස් (comments) හෝ Javadoc තුළ ලියන්න.

පොදු වැරදි අදහස් සහ විසඳුම්

null.equals() නරක භාවිතය

// Unsafe example
if (obj.equals("test")) {
    // ...
}

සෑම විටම equals() ක්‍රමය null නොවන වස්තුවකින් කැඳවන්න.

null පරීක්ෂණ අධික භාවිතය

අධික null පරීක්ෂණ කේතය ගැලපී යාමට හා කියවීමට අපහසු කරයි.

• ක්‍රම නිර්මාණය කර null ආපසු ලබා නොදෙන්න.
• Optional හෝ හිස් එකතු කිරීම් භාවිතා කරන්න.
• හැකි තරම් null පරීක්ෂණ එකම ස්ථානයේ රැස් කරන්න.

null වලින් වැළැක්වීමට නිර්මාණ ක්‍රම

• Optional භාවිතා කර අගයක් නොමැති බව පැහැදිලිව නිරූපණය කරන්න.
• Null Object Pattern භාවිතා කර null වෙනුවට නිර්වචිත හැසිරීමක් ලබා දෙන්න.
• පෙරනිමි අගයන් භාවිතා කර තර්කය සරල කරන්න.

null හසුරවීම සඳහා පුස්තකාල සහ මෙවලම්

Apache Commons Lang – StringUtils

String str = null;
if (StringUtils.isEmpty(str)) {
    // true if null or empty
}

String str = "  ";
if (StringUtils.isBlank(str)) {
    // true if null, empty, or whitespace
}

Google Guava – Strings

String str = null;
if (Strings.isNullOrEmpty(str)) {
    // true if null or empty
}

පුස්තකාල භාවිතා කරන විට සටහන්

• අතිරේක පරාමිතීන් ගැන සැලකිලිමත් වන්න.
• ප්‍රමිත API පරිපූර්ණ වන විට බාහිර පුස්තකාල වලින් වළකින්න.
• කණ්ඩායමේ ඇතුළත භාවිත නීති ස්ථාපිත කරන්න.

නිගමනය

මෙම ලිපිය ජාවා null සැකසීමේ මූලිකත්වයන් සිට හොඳම ක්‍රියාමාර්ග සහ වාස්තුකාලීන තාක්ෂණයන් දක්වා ආවරණය කරයි.

මූලික null පරීක්ෂණයන් Optional සමඟ, ආරක්ෂක වැඩසටහන්, පැහැදිලි කේත ප්‍රමිතීන්, සහ සුදුසු පුස්තකාල සමඟ එකතු කිරීමෙන්, ඔබට කේත ආරක්ෂාව, කියවීමට පහසුව, සහ නඩත්තුකරණය විශාල ලෙස වැඩිදියුණු කළ හැක.

Null සැකසීම සරල ලෙස පෙනී හැරිය හැකි නමුත්, එය මෘදුකාංග ගුණාත්මකභාවයට වැදගත් බලපෑම් කරන ගැඹුරු විෂයයකි. මෙම ක්‍රියාමාර්ග ඔබේම ව්‍යාපෘති සහ කණ්ඩායම් වැඩපිළිවෙළට යොදා ගනිමින්, වඩා ශක්තිමත් ජාවා යෙදුම් ලබා ගන්න.

නිතර අසන ප්‍රශ්න

Q1: null සහ හිස් අක්ෂර මාලාව අතර වෙනස කුමක්ද?

A: null යනු කිසිදු වස්තුවක් නොමැති බවයි, එත් හිස් අක්ෂර මාලාව යනු ශූන්‍ය දිගකින් යුත් වලංගු වස්තුවකි.

Q2: null සමඟ equals() භාවිතා කරන විට මට කුමන කරුණකට සැලකිලිමත් විය යුතුද?

A: සම්භාව්‍ය null වස්තුවක් මත equals() කැඳවන්න එපා. ඒ වෙනුවට null නොවන literals (අක්ෂර) මගින් කැඳවන්න.

Q3: Optional භාවිතයේ ප්‍රතිලාභ මොනවාද?

A: Optional හිස්භාවය පැහැදිලිව නියෝජනය කරයි, පරීක්ෂණයන් අත්‍යවශ්‍ය කරයි, සහ null-සම්බන්ධ දෝෂ අඩු කරයි.

Q4: null පරීක්ෂණ සඳහා කෙටි මාර්ග තිබේද?

A: StringUtils සහ Guava Strings වැනි උපකාරක ක්‍රමයන් null සහ හිස් පරීක්ෂණ සරල කරයි.

Q5: null වලින් වැළැක්වීමට කේතය කෙසේ නිර්මාණය කළ හැකිද?

A: හිස් එකතු කිරීම් හෝ Optional ආපසු ලබා දෙන්න, nullable පරාමිතීන් වලින් වළකින්න, සහ පෙරනිමි අගයන් නියම කරන්න.

Q6: අධික null පරීක්ෂණ අඩු කිරීම කෙසේද?

A: non-null නිර්මාණ නීති අත්‍යවශ්‍ය කරමින්, ව්‍යාපෘතිය පුරා Optional එකසේ භාවිතා කරන්න.