Java හි int සහ Integer අතර අවබෝධය: ප්‍රධාන වෙනස්කම්, හොඳම ක්‍රියා පටිපාටියන්, සහ පොදු වැරදි

1. හැඳින්වීම

ජාවාහි පූර්ණ සංඛ්‍යා වර්ගයන්ගේ මූලික කරුණු

ජාවා තුළ සංඛ්‍යා සමඟ වැඩ කරන විට, අතිමූලික දත්ත වර්ග之一 වන “පූර්ණ සංඛ්‍යා වර්ගය” (int) වේ. එය මූලික වර්ගයක් වන අතර වැඩසටහන් තුළ සංඛ්‍යා ගණනය සඳහා නිතර භාවිතා කරයි, වේගවත් හා මතක‑කාර්යක්ෂම සැකසීම සලසයි.

එසේම, ජාවා Integer නමැති පන්තියක් ද ලබා දේ. මෙය වෙළඳ පන්තිය (wrapper class) ලෙස හැඳින්වේ, එය int අගයන් වස්තු ලෙස සැලැස්වීමට ඉඩ සලසයි, ජාවාගේ වස්තු‑ආධාරිත දර්ශනයට අනුකූලව.

මෙම දෙකම සමාන පෙනුමක් ඇති වුවත්, ඒවායේ අරමුණ සහ හැසිරීමේ පැහැදිලි වෙනස්කම් ඇත. එබැවින්, ජාවා ආරම්භකයන් බොහෝවිට “int සහ Integer අතර වෙනස කුමක්ද?” හෝ “එක් එක් වර්ගය නිසි ලෙස කෙසේ භාවිතා කළ යුතුද?” යන ප්‍රශ්න අසති.

Integer පන්තිය ගැන ඔබට ඉගෙන ගැනීමට ඇයි අවශ්‍ය?

ජාවා තුළ බොහෝ අවස්ථා ඇත—උදාහරණként එකතු කිරීමේ රාමුව (List හෝ Map වැනි), null අගයන් සැකසීම, හෝ generic භාවිතය—ඒවායේ මූලික int වර්ගය සුදුසු නොවේ. එවැනි අවස්ථා වල Integer පන්තිය අත්‍යවශ්‍ය වේ, එබැවින් එහි මූලික කරුණු අවබෝධ කර ගැනීම වැදගත්.

Integer පන්තිය ස්ට්‍රින්ග් සහ සංඛ්‍යා අතර පරිවර්තනය, සසඳුම්, බිට්‑වයිස් මෙහෙයුම් වැනි කාර්ය සඳහා ප්‍රයෝජනවත් ක්‍රම රැසක් ලබා දේ. මෙම ක්‍රමවල පරිපූර්ණ දැනුම ඔබට වඩා ශක්තිමත් හා කියවීමට පහසු කේතයක් ලිවීමට ඉඩ සලසයි.

මෙම ලිපිය Integer පන්තිය මත කේන්ද්‍රගත කරයි, එය int වලින් කෙසේ වෙනස්ද, එය කෙසේ භාවිතා කළ යුතුද, සහ ප්‍රායෝගික භාවිත උදාහරණ කුමනද යන්න පැහැදිලි කරයි. ඔබ ජාවා ආරම්භකයෙක් වුවත්, හෝ සමහර අත්දැකීම් ඇතිවුවත්, මෙහි ප්‍රයෝජනවත් තොරතුරු සොයාගත හැක—ඉදිරියට කියවන්න!

2. Integer පන්තිය කුමක්ද?

වෙළඳ පන්තියක් ලෙස භූමිකාව

ජාවා Integer පන්තිය වෙළඳ පන්තියක් වන අතර, මූලික int වර්ගය වස්තුවක් ලෙස සැලැස්වීමට ඉඩ සලසයි. නාමය පෙන්වන පරිදි, වෙළඳ පන්තියක් යමක් “වෙළඳ” කරයි—මෙහිදී, කච්චා int අගයක් Integer “කට්ටලයක්” තුළ ඇතුළත් කරයි, එවිට එය වස්තුවක් ලෙස භාවිතා කළ හැක.

උදාහරණයක් ලෙස, ජාවා එකතුකිරීම් (List සහ Map වැනි) වස්තු පමණක් සැලැස්විය හැක. මූලික වර්ගයන් වන int සෘජුව භාවිතා කළ නොහැකි බැවින්, ඒ වෙනුවට Integer අවශ්‍ය වේ.

List<Integer> numbers = new ArrayList<>();
numbers.add(10); // The int value 10 is automatically converted to Integer and stored

int අගයන් වස්තු ආකාරයට (boxing) පරිවර්තනය කිරීමෙන්, ඔබට බොහෝ ජාවා API සහ රාමුවල සමඟ අඩු බාධාවකින් වැඩ කළ හැක.

ස්වයං‑බොක්සිං සහ අන්බොක්සිං

ජාවා 5 සිට, “autoboxing” සහ “unboxing” ලෙස හැඳින්වෙන පහසු විශේෂාංග හඳුන්වා දී ඇත.

• Autoboxing : int අගයක් ස්වයංක්‍රීයව Integer වස්තුවකට පරිවර්තනය වේ
• Unboxing : Integer වස්තුව ස්වයංක්‍රීයව int අගයක් වෙයි

  Integer num = 100; // Autoboxing
  int result = num + 50; // Unboxing occurs for the calculation
  

මෙම අර්ථය වන්නේ සංවර්ධකයන්ට පැහැදිලි පරිවර්තන කේතය ලිවීමට අවශ්‍ය නොවීම—ජාවා පරිවර්තන ස්වයංක්‍රීයව කළමනාකරණය කරයි, එමඟින් ඔබේ කේතය සරල හා කියවීමට පහසු වේ.

කෙසේ වෙතත්, null අගයක් අන්බොක්ස් කිරීමට උත්සාහ කළහොත්, NullPointerException එකක් සිදුවේ, එබැවින් අවධානයෙන් සිටින්න.

Integer value = null;
int x = value; // This throws an exception

Integer හි වැදගත්කම

Integer පන්තිය int සඳහා පමණක් ප්‍රතිස්ථාපකයක් නොවේ. වස්තුවක් ලෙස, එයට විශේෂ ගුණාංග ඇත:

• null අගයක් නියම කළ හැක, එය “අසකස්” තත්ත්වයක් නිරූපණය කරයි
• එය ලවච්චිත මෙහෙයුම් සදහා ක්‍රම රැසක් සමඟ පැමිණේ
• එකතුකිරීම් සහ අනෙකුත් වස්තු‑මූලික ව්‍යුහයන්හි භාවිතා කළ හැක

සාරාංශයෙන්, ජාවාගේ වස්තු‑ආධාරිත පරිසරයේ Integer int ට වඩා සුදුසු වන බොහෝ අවස්ථා පවතී.

3. Integer පන්තියේ ප්‍රධාන ක්ෂේත්‍ර සහ ස්ථිරයන්

ජාවා Integer පන්තිය සංඛ්‍යා සම්බන්ධ තොරතුරු ලබා ගැනීමට ප්‍රයෝජනවත් ස්ථිරයන් සහ ක්ෂේත්‍ර කිහිපයක් නිර්වචනය කරයි. මෙවලම් භාවිතා කිරීමෙන් ඔබේ කේතයේ කියවීමට පහසුව සහ නඩත්තු කිරීමේ හැකියාව වැඩි වේ.

අපි සාමාන්‍යයෙන් භාවිතා වන ක්ෂේත්‍ර කිහිපයක් සමාලෝචනය කරමු.

MAX_VALUE සහ MIN_VALUE

Integer.MAX_VALUE සහ Integer.MIN_VALUE යනු int වර්ගය ගත හැකි උපරිම සහ අවම අගයන් නියෝජනය කරන ස්ථිරයන් වේ.

.

• MAX_VALUE : 2,147,483,647 (2 රු 31 වන ධාරිතාවය මයිනස් 1)
• MIN_VALUE : -2,147,483,648 (ඍණ 2 රු 31 වන ධාරිතාවය)

මෙම අගයන් සාමාන්‍යයෙන් පරාස පරීක්ෂණය හෝ අධිප්‍රවාහය වැළැක්වීමට භාවිතා කරයි, එමනිසා ඒවා ආරක්ෂිත සංඛ්‍යාත්මක සැකසීම සඳහා අත්‍යවශ්‍ය වේ.

int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;

System.out.println("Max value: " + max); // 2147483647
System.out.println("Min value: " + min); // -2147483648

SIZE සහ BYTES

SIZE සහ BYTES යනු int වර්ගය භාවිතා කරන බිට් ගණන සහ බයිට් ගණන පෙන්වන ස්ථිර අගයන් වේ.

• Integer.SIZE : 32 (බිට් ගණන)
• Integer.BYTES : 4 (බයිට් ගණන)

මෙම අගයන් බයිනරි දත්ත සමඟ කටයුතු කරන විට හෝ පද්ධති වැඩසටහන් අවස්ථා වල, දත්ත ප්‍රමාණ ගණනය කිරීම හෝ ගුප්තකේත අරමුණු සඳහා සාමාන්‍යයෙන් භාවිතා කරයි.

System.out.println("Number of bits in int: " + Integer.SIZE);   // 32
System.out.println("Number of bytes in int: " + Integer.BYTES); // 4

TYPE ක්ෂේත්‍රය

Integer.TYPE යනු int වර්ගය සඳහා Class වස්තුව ලබා දෙන ස්ථිර ක්ෂේත්‍රයකි. මෙය සමහරවිට උත්කර්ෂණ වැඩසටහන් තාක්ෂණ (reflection) හෝ generics වැනි උසස් වැඩසටහන් ක්‍රම සඳහා භාවිතා කරයි.

Class<?> clazz = Integer.TYPE;
System.out.println(clazz.getName()); // int

එය දිනපතා සංවර්ධනයේ බොහෝ විට භාවිතා නොවුවත්, ඔබ Java අභ්‍යන්තර හෝ රාමු සංවර්ධනය ගැන රුචිව සිටිනවා නම්, එය දැන ගැනීම වටිනවා.

මෙම සියලු ස්ථිර අගයන් static final ලෙස නිර්වචනය කර ඇත, එනම් ඔබට Integer පන්තියෙන් සෘජුවම ඒවාට ප්‍රවේශ විය හැක, නව උදාහරණයක් සෑදීමට අවශ්‍ය නොවේ. මෙම වර්ග-සම්බන්ධ ස්ථිර අගයන් දැන ගැනීම Java හි දෝෂ වැළැක්වීම සහ කාර්ය සාධනය වැඩිදියුණු කිරීම සඳහා හොඳ පළමු පියවරකි.

4. Integer පන්තියේ ප්‍රධාන ක්‍රම

Integer පන්තිය int සඳහා පමණක් ආවරණයක් නොව, එය ස්ට්‍රින් පරිවර්තනය, සංඛ්‍යාත්මක සැසඳීම, බිට්wise මෙහෙයුම් සහ තවත් බොහෝ ප්‍රායෝගික ක්‍රම ලබා දේ—එමනිසා දිනපතා Java සංවර්ධනය සඳහා ඉතා ප්‍රයෝජනවත් වේ. මෙහි, අපි ප්‍රවර්ග අනුව වැඩිම වාරිකව භාවිතා වන ක්‍රම හඳුන්වා දෙමු.

පරිවර්තන ක්‍රම

parseInt()

parseInt() යනු ස්ට්‍රින් එකක් int අගයක් බවට පරිවර්තනය කරන ස්ථිර ක්‍රමයකි. එය ප්‍රධාන වශයෙන් පරිශීලක ඇතුළත් කිරීම හෝ බාහිර ගොනු වල දත්ත සංඛ්‍යා ලෙස සැකසීමට අවශ්‍ය වන විට භාවිතා කරයි.

String str = "123";
int number = Integer.parseInt(str); // 123

• සංඛ්‍යාත්මක නොවන ස්ට්‍රින් එකක් ලබා දුන් විට, NumberFormatException එකක් නක්ෂේපණය වේ, එබැවින් try‑catch භාවිතා කිරීම ආරක්ෂිත වේ.

valueOf()

valueOf() යනු ස්ට්‍රින් එකක් හෝ int අගයක් Integer වස්තුවකට පරිවර්තනය කරන ක්‍රමයකි. parseInt() වෙනුවට, එහි ආපසු ලබා දෙන වර්ගය Integer වේ, int නොවේ.

Integer num1 = Integer.valueOf("456");
Integer num2 = Integer.valueOf(789);

Integer.valueOf() -128 සහ 127 අතර අගයන් සඳහා කැෂ් වස්තු නැවත භාවිතා කරයි, එමනිසා new භාවිතයෙන් නව උදාහරණ සෑදීමට වඩා කාර්යක්ෂම වේ.

ප්‍රදර්ශන සහ පරිවර්තන ක්‍රම

toString()

toString() යනු සංඛ්‍යාත්මක අගයක් ස්ට්‍රින් ලෙස ලබා දෙන ක්‍රමයකි. එය සාමාන්‍යයෙන් ස්ට්‍රින් එකතු කිරීම හෝ අගයන් ප්‍රදර්ශනය කිරීම සඳහා භාවිතා කරයි.

int number = 100;
String str = Integer.toString(number); // "100"

ඔබට එය බයිනරි හෝ හෙක්සඩෙසිමල් වැනි වෙනත් පදනම් වලට පරිවර්තනය කිරීමටද භාවිතා කළ හැක.

System.out.println(Integer.toBinaryString(10));  // "1010"
System.out.println(Integer.toHexString(255));    // "ff"

සැසඳීමේ ක්‍රම

compareTo()

compareTo() යනු Integer වස්තු දෙකක් සැසඳීම කරන ක්‍රමයකි, එය ඒවායේ සාපේක්ෂ අනුක්‍රමය පෙන්වන පූර්ණ සංඛ්‍යාවක් ආපසු ලබා දේ.

Integer a = 10;
Integer b = 20;

int result = a.compareTo(b); // -1 (returns a negative value if a < b)

එය Collections.sort වැනි ක්‍රම සමඟ එකට බොහෝ විට භාවිතා වේ.

equals()

equals() යනු අගයන් දෙක සමානදැයි පරීක්ෂා කරන ක්‍රමයකි. == මෙහෙයුම්කරු යොමුකිරීම් (references) සැසඳේ, එබැවින් වස්තු අගයන් සැසඳීමට equals() භාවිතා කිරීම සුදුසුය.

Integer x = 100;
Integer y = 100;
System.out.println(x.equals(y)); // true

බිට්wise මෙහෙයුම් ක්‍රම

ජාවා පන්ති අතරින් විශේෂයෙන්ම, Integer පන්තිය අඩු-පෙළ bitwise මෙහෙයුම් සඳහා විස්තීර්ණ සහායක් ලබා දෙයි。

bitCount()

මෙම ක්‍රමය දක්වා ඇති int වටිනාකමේ 1 ලෙස සකස් කර ඇති බිට් ගණන ආපසු ලබා දෙයි。

int count = Integer.bitCount(15); // 15 in binary is 1111 → 4 bits set to 1

highestOneBit()

මෙම ක්‍රමය දක්වා ඇති int වටිනාකමෙන් ඉහළම-පෙළ one bit පමණක් සකස් කර ඇති වටිනාකම ආපසු ලබා දෙයි。

int highest = Integer.highestOneBit(10); // 10 (1010) → 8 (1000)

Bitwise මෙහෙයුම් සම්බන්ධ වශයෙන් ඔප්ටිමයිසේෂන් සඳහා ඉතා උපකාරීය.

අනෙකුත් ප්‍රයෝජනවත් ක්‍රම

• Integer.reverse(int) : බිට් අනුපිළිවෙල ප්‍රතිවර්තනය කරයි
• Integer.signum(int) : සංඥාව ආපසු ලබා දෙයි (ධන: 1, ඍණ: -1, සීරෝ: 0)
• Integer.hashCode() : හැෂ් කෝඩ් එකක් ආපසු ලබා දෙයි (කලෙක්ෂන්ස් භාවිතා කිරීමේදී වැදගත්)

ජාවාහි ඇතැම් තැනක ඕනෑම තැනක සංඛ්‍යාල භාවිතා වේ. මෙම ක්‍රම පමණක් දැනගැනීමෙන් ඔබට අඩුපාඩු සහ කාර්යක්ෂම කේතයක් ලිවීමට උපකාරී වේ. විශේෂයෙන්ම, පරිවර්තනය, සංසන්දනය සහ bitwise ක්‍රම පුහුණුවේදී සාමාන්‍යයෙන් භාවිතා වන බැවින්, ඒවා ප්‍රවේශම් කරගන්න.

5. int සහ Integer අතර තේරීම

ජාවාහි, සංඛ්‍යාල නිරූපණය කිරීම සඳහා තුනේ වර්ග දෙකක් තිබේ: int සහ Integer. ඒවා අතර පරිවර්තනය කළ හැකි වුවද, ඒවා වැරදි ලෙස භාවිතා කිරීමෙන් කාර්ය සාධනයේ ගැටලු හෝ අනපේක්ෂිත දෝෂ ඇති විය හැක. ඒවායේ ලක්ෂණ සහ එක් එක් තත්ත්වය සඳහා නිවැරදි එක තෝරාගැනීම ගැන සලකා බලමු.

කාර්ය සාධනය අනුව වෙනස්කම්

int යනු මූලික වර්ගයක් වන අතර, නිශ්චිත මතක ප්‍රමාණයක් (බাইට් 4) ඇති අතර, ගණනය කිරීම සඳහා ඉතා වේගවත්. Integer, එහෙත්, වස්තු වර්ගයක් වන අතර, heap හි උදාහරණයක් ලෙස සංරක්ෂණය වන අතර, ක්‍රම සහ අමතර විශේෂාංග ලබා දෙයි.

int a = 10;
Integer b = 10;

එකම වටිනාකම පැවරීමට වුවද, අභ්‍යන්තර භාවිතය වෙනස් වේ. ඝන ගණනයන් හෝ ලූප් සඳහා, int භාවිතා කිරීම ඉතා වේගවත් සහ මතක-කාර්යක්ෂම වේ.

උදාහරණය: ලූප්වල කාර්ය සාධනයේ වෙනස

long startTime = System.nanoTime();
int sum = 0;
for (int i = 0; i < 1000000; i++) {
    sum += i;
}
long endTime = System.nanoTime();
System.out.println("Time for int: " + (endTime - startTime) + " ns");

Integer සමඟ එකම දේ කිරීමෙන් boxing සහ unboxing overhead ඇති වන අතර, එය කිහිපයක් වේගයෙන් මන්දගාමී කළ හැක.

Nullability සහ Exception Handling වෙනස්කම්

int null පැවරීමට නොහැක. එබැවින් “කිසිදු වටිනාකමක් නැත” හෝ “සකස් නොකර ඇත” නිරූපණය කිරීමට අවශ්‍ය වන විට එය සුදුසු නොවේ.

Integer value = null;
if (value == null) {
    System.out.println("Value is unset");
}

Integer සමඟ, ඔබට null පැහැදිලිව හැසිරවිය හැක, එබැවින් එය ආකෘති සත්‍යාපනය හෝ දත්ත සමුදාය ලබාගැනීම වැනි තත්ත්වයන්හි වටිනාකමක් නොමැති විය හැකි තැන්වල යෝග්‍ය වේ.

කෙසේ වෙතත්, null Integer එකක් int ට unboxing කිරීමෙන් NullPointerException එකක් දමනු ලැබේ, එබැවින් සැලකිලිමත් විය යුතුය.

කලෙක්ෂන්ස් සමඟ සමගිය

ජාවා කලෙක්ෂන්ස් (List සහ Map වැනි) වස්තු පමණක් සංරක්ෂණය කළ හැක. එබැවින් ඔබට int එකක් සෘජුව භාවිතා කළ නොහැක; ඒ වෙනුවට Integer අවශ්‍ය වේ.

List<Integer> numbers = new ArrayList<>();
numbers.add(100); // int → Integer via autoboxing

එසේම, generics සමඟ වැඩ කිරීමේදී, ඔබට මූලික වර්ගයක් වර්ග තර්කයක් ලෙස නිර්දේශ කළ නොහැක, එබැවින් ඔබම Integer භාවිතා කළ යුතුය.

සාරාංශය: තෝරාගැනීමේ මාර්ගෝපදේශ

මූලික වශයෙන්, මතක තබාගන්න: වේගය සඳහා int භාවිතා කරන්න, නමුත් විනූවන්කම සඳහා Integer.

6. සාමාන්‍ය දෝෂ සහ ඒවා හැසිරවීම

NullPointerException

හේතුව:

Integer යනු වස්තු වර්ගයක් වන බැවින්, එය null පැවරිය හැක, නමුත් null Integer එකක් int ට unbox කිරීමට උත්සාහ කළහොත්, NullPointerException එකක් සිදු වේ.

Integer value = null;
int x = value; // Exception thrown here

විසඳුම:

Unboxing කිරීමට පෙර සැමවිටම null සඳහා පරීක්ෂා කරන්න.

if (value != null) {
    int x = value;
} else {
    int x = 0; // Assign a default value
}

විකල්පයක් ලෙස, ඔබට Optional (Java 8+) භාවිතා කරමින් මෙය ආරක්ෂිතව හැසිරවිය හැක:

int x = Optional.ofNullable(value).orElse(0);

NumberFormatException

හේතුව:

This exception is thrown when Integer.parseInt() or Integer.valueOf() is used to convert a අංක නොවන ස්ට්‍රින්.

String input = "abc";
int num = Integer.parseInt(input); // NumberFormatException

විසඳුම:

ආදානය අංකයක්දැයි පෙර පරීක්ෂා කරන්න, සාමාන්‍යයෙන් නියමිත ප්‍රකාශනයක් (regular expression) භාවිතා කර.

if (input.matches("-?\\d+")) {
    int num = Integer.parseInt(input);
} else {
    System.out.println("Not a numeric value");
}

එසේම, try-catch භාවිතා කර εξαදෝෂයන් හසුරවමින් ආරක්ෂිත සැකසීමක් සනාථ කරන්න.

try {
    int num = Integer.parseInt(input);
} catch (NumberFormatException e) {
    System.out.println("Invalid number format: " + input);
}

== සහ equals() භාවිතයේ වැරදි

හේතුව:

== භාවිතයෙන් Integer වස්තු දෙකක් සසඳන විට, ඔබ ඔවුන්ගේ යොමුකිරීම් (references) සසඳයි, අගයන් නොව. එබැවින් අගයන් එකසේ වුවත්, වස්තු දෙක වෙනස් නම් false ලබා ගත හැක.

Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a == b);       // false (different references)
System.out.println(a.equals(b)); // true (same value)

• -128 සහ 127 අතර අගයන් සඳහා, වස්තු කෑෂ් කර ඇත, එබැවින් == සත්‍ය (true) විය හැක. නමුත්, මෙය ක්‍රියාත්මක කිරීමේ විධානයට අනුව වෙනස් වේ.

විසඳුම:

දෙක Integer වස්තු සසඳීමට සෑමවිටම .equals() භාවිතා කරන්න.

if (a.equals(b)) {
    System.out.println("Values are equal");
}

අනබොක්සිං කිරීමෙන් පසු ඔවුන්ගේ primitive int අගයන් සසඳා ගත හැක.

if (a.intValue() == b.intValue()) {
    System.out.println("Equal as int values");
}

අතිකාලය (Overflow) නොසලකා හැරීම

හේතුව:

int සහ Integer 32-බිට් අගයන් (±2,147,483,647) පමණක් හසුරවයි. ඔබ මෙම පරාසය ඉක්මවා ගත්තාම, ඒවා නිවැරදිව ක්‍රියා නොකරයි.

int a = Integer.MAX_VALUE;
int b = a + 1;
System.out.println(b); // -2,147,483,648 (wraps around to negative)

විසඳුම:

අවශ්‍ය නම් long හෝ BigInteger භාවිතා කිරීම ගැන සිතන්න, සහ සෑමවිටම සීමා ගැන අවධානයෙන් සිටින්න.

සාරාංශය

Integer පහසු සහ ලවච්චිත වුවද, null, යොමුකිරීම්, සහ වර්ග පරිවර්තන සම්බන්ධයෙන් බොහෝ සීමා සහිත වේ. විශේෂයෙන් Java ආරම්භකයන්ට, කිසිඳු εξαදෝෂයන් ඇයි සිදුවන්නේ යන්න තේරුම් ගැනීම වැදගත්.

ඔබ මෙම පොදු වැරදි පෙර දැනුවත් නම්, දෝෂ වලක්වා තවත් ස්ථාවර කේතයක් ලියන්න පුළුවන්.

7. ප්‍රායෝගික උදාහරණ: Integer පන්තිය කෙසේ භාවිතා කරයි

මෙතෙක්, ඔබ Integer පන්තිය පිළිබඳ ලක්ෂණ, වෙනස්කම්, සහ වැදගත් කරුණු පිළිබඳ පූර්ණ අවබෝධයක් ලබාගෙන ඇති බවක්. ඉදිරියට, Integer සාමාන්‍යයෙන් භාවිතා වන ප්‍රායෝගික අවස්ථා කිහිපයක් බලමු.

පරිශීලක ආදානය අංක වලට පරිවර්තනය කිරීම

වෙබ් සහ ඩෙස්ක්ටොප් යෙදුම් වල, පරිශීලක ආදානය සාමාන්‍යයෙන් String ලෙස ලැබේ. නමුත් වයස හෝ ප්‍රමාණය වැනි ක්ෂේත්‍රවල, එය අංක ලෙස සැකසීමට අවශ්‍ය වේ, එවිට Integer මෙම පරිවර්තනය සඳහා උපකාරී වේ.

String input = "25"; // User input as a string

try {
    Integer age = Integer.valueOf(input); // Convert String → Integer
    System.out.println("Age: " + age);
} catch (NumberFormatException e) {
    System.out.println("Invalid input");
}

ආදානය නිවැරදි අංකයක්දැයි පරීක්ෂා කර දෝෂ හසුරවීමෙන්, ආරක්ෂිත පරිශීලක ආදාන සැකසීම ලබා ගත හැක.

වින්‍යාස අගයන් සහ පරිසර විචල්‍යයන් කළමනාකරණය

පද්ධතියේ හෝ වින්‍යාස අගයන් ස්ට්‍රින් ලෙස කියවා පසුදා Integer වෙත පරිවර්තනය කිරීම සාමාන්‍යයයි. උදාහරණයක් ලෙස, System.getProperty() භාවිතා කරන විට, ප්‍රතිඵලය පාර්ස් (parse) කිරීම අවශ්‍ය වේ.

String maxConn = System.getProperty("app.maxConnections", "100");
int max = Integer.parseInt(maxConn);
System.out.println("Max connections: " + max);

එවැනි අවස්ථාවල, තාර්කික පෙරනිමි අගයන් ලබා දීම සහ වින්‍යාස වෙනස්කම් සවිස්තරාත්මකව ඉඩ දීම වැදගත් වේ.

එකතුකිරීම් (Collections) තුළ අංක සමඟ වැඩ කිරීම

.When you want to handle numbers within a collection (like a List), you need to use Integer instead of int. For instance, you might temporarily store a list of IDs entered by the user.

List<Integer> ids = new ArrayList<>();
ids.add(101);
ids.add(205);
ids.add(309);

for (Integer id : ids) {
    System.out.println("Processing ID: " + id);
}

Thanks to autoboxing, the conversion from int to Integer happens automatically, so you can write concise code without worrying about manual conversion.

බිට් මෙහෙයුම් භාවිතා කර කොඩි කළමනාකරණය

The Integer class is rich in bit manipulation methods, which is useful for low-level flag management and state transitions.

int flags = 0;

// Set the 1st bit
flags |= 0b0001;

// Set the 2nd bit
flags |= 0b0010;

// Check if the 2nd bit is set
boolean isSet = (flags & 0b0010) != 0;

System.out.println("The 2nd bit is: " + (isSet ? "ON" : "OFF"));

And you can use Integer.toBinaryString(flags) to visualize the flag state:

System.out.println("Current flag state: " + Integer.toBinaryString(flags));

දත්ත ගබඩා සමඟ වැඩ කිරීම

When using JDBC or similar methods to interact with databases, using Integer (not int) for numeric columns allows you to safely handle null values.

ResultSet rs = stmt.executeQuery("SELECT age FROM users WHERE id = 1");

if (rs.next()) {
    Integer age = (Integer) rs.getObject("age");
    System.out.println(age != null ? "Age: " + age : "Age not set");
}

Since primitive int cannot be null, Integer is the appropriate choice here.

සාරාංශය

The Integer class is more than just a wrapper for int—it plays a key role in flexible data handling and ensuring safety in real‑world development. It is especially useful in the following cases:

• පරිශීලක ඇතුළත් කිරීම හෝ බාහිර සැකසුම් සංඛ්‍යාත බවට පරිවර්තනය කිරීම
• null විය හැකි දත්ත හසුරවීම
• එකතුකිරීම් (collections) තුළ පූර්ණ සංඛ්‍යා (integers) සුරැකීම
• බිට් මෙහෙයුම් භාවිතා කර තත්ත්ව කළමනාකරණය

By mastering Integer, you can write code that is more extensible, maintainable, and stable.

8. නිගමනය

Java’s Integer class is not just a substitute for int—it’s a crucial class that closely relates to Java’s object‑oriented nature. In this article, we explained the following points in a way that’s easy for beginners to understand, while also covering practical aspects:

Integer පන්තියේ වාසි මොනවාද?

• එය වස්තුවක් ලෙස සැලකිය හැකි බැවින්, null අගයන් සමඟ වැඩ කළ හැකි අතර, එකතුකිරීම් (collections) සමඟ භාවිතා කළ හැක
• බොහෝ පහසු ක්‍රම (string පරිවර්තනය, සසඳීම, බිට් මෙහෙයුම්, සහ තවත්) සමඟ එය පැමිණේ
• System.getProperty() සහ දත්ත ගබඩා මෙහෙයුම් සමඟ හොඳින් ක්‍රියා කර, ආකාරවත් නිර්මාණයක් සලසයි
• වස්තු කෑෂ් කිරීම සහ autoboxing මඟින් කේතය සරල හා කෙටි කරයි

These are advantages you can’t get with the primitive int type.

නමුත් මෙහි වැදගත් අවධානම්ද ඇත

• null Integer එකක් Unboxing කිරීමෙන් NullPointerException එකක් සිදුවේ
• == මෙහෙයුම භාවිතා කිරීමෙන් ඔබේ අපේක්ෂා පරිදි අගයන් සසඳා නොගත හැක
• කාර්ය සාධනයේදී විශාල පරිමාණ සංඛ්‍යා ගණනය සඳහා int වඩා හොඳයි

Failing to understand these points can lead to unexpected bugs or performance problems.

නිවැරදි වර්ගය තෝරා ගැනීම මූලිකය

In summary, int and Integer are not just different types, but should be chosen appropriately based on your design goals and use case.

අවසාන අදහස්

Understanding Integer is foundational not only for handling data types in Java, but also for developing deeper programming skills in object‑oriented design, exception handling, and performance optimization.

Because integer types are so commonly used, gaining a thorough understanding early on will be a huge asset in your future Java development journey.

නිතර අසන ප්‍රශ්න (FAQ)

ප්‍ර.1. int සහ Integer අතර වෙනස කුමක්ද?

A. int යනු Java හි ප්‍රාථමික වර්ගයක් වන අතර පූර්ණ සංඛ්‍යා අගයන් කාර්යක්ෂම හා වේගවත් ලෙස හසුරවීමට භාවිතා වේ. Integer යනු වෙරප්පර් පන්තිය (wrapper class) වන අතර int එකක් වස්තුවක් ලෙස සැලකීමට ඉඩ දේ, එමඟින් null අගයන් සමඟ වැඩ කිරීම සහ විවිධ ක්‍රම භාවිතා කිරීම සලස්වයි. උදාහරණයක් ලෙස, අගයන් එකතුවක (collection) ගබඩා කිරීමේදී හෝ සකස් කර ඇති සහ නොසකස් කර ඇති අගයන් අතර වෙනස්කම් හඳුනා ගැනීමේදී Integer වඩා සුදුසු වේ.

Q2. parseInt() සහ valueOf() අතර වෙනස කුමක්ද?

A. දෙකම 문자열යක් (string) සංඛ්‍යාවකට පරිවර්තනය කරයි, නමුත් ආපසු ලැබෙන වර්ග (type) වෙනස් වේ:

• parseInt(String s) → int (ප්‍රාථමික වර්ග) ලබා දෙයි
• valueOf(String s) → Integer (වස්තු වර්ග) ලබා දෙයි

ඔබේ අවශ්‍යතා අනුව තෝරන්න. ඔබට වස්තුවක් අවශ්‍ය නම් හෝ null අගයන් හසුරවීමට අවශ්‍ය නම් valueOf() වඩා ප්‍රයෝජනවත් වේ.

Q3. Integer වස්තු සසඳීමට == භාවිතා නොකළ යුත්තේ ඇයි?

A. == මෙහෙයුම්කරු වස්තු යොමුකිරීම් (object references) සසඳයි, අගයන් නොව. අගයන් එකසේ වුවත්, ඒවා වෙනත් උදාහරණ (instances) නම් false ලැබිය හැක. 128 හෝ ඊට වැඩි අගයන් සඳහා, වස්තු කෑෂ් (caching) ක්‍රියා නොකරන බැවින්, අනපේක්ෂිත ප්‍රතිඵල ලැබිය හැක. අගයන් සසඳීමට සෑමවිටම .equals() භාවිතා කරන්න.

Integer a = 128;
Integer b = 128;
System.out.println(a == b);       // false (different references)
System.out.println(a.equals(b)); // true (same value)

Q4. Integer එකකට null අගයක් නියෝජනය කළහොත් කුමක් සිදුවේ?

A. Integer වස්තුවක් වන බැවින්, ඔබට null නියෝජනය කළ හැක. නමුත්, එය null තත්ත්වයේ සිට int (අප්‍රාථමික) වෙත පරිවර්තනය (unbox) කරනවා නම්, NullPointerException එකක් සිදුවේ.

Integer val = null;
int num = val; // Exception thrown here

null පරීක්ෂා කිරීම හෝ ආරක්ෂිත කේතයක් සඳහා Optional භාවිතා කිරීම අත්‍යවශ්‍ය වේ.

Q5. Integer හි උපරිම සහ අවම අගයන් කෙසේ සොයාගත හැකිද?

A. Java හි, Integer.MAX_VALUE සහ Integer.MIN_VALUE භාවිතා කර මෙම සීමා පහසුවෙන් ලබා ගත හැක.

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648

මෙම අගයන් පරාස පරීක්ෂා කිරීම සහ අතිකාල (overflow) ආරක්ෂාව සඳහා ප්‍රයෝජනවත් වේ.

Q6. එකතුකිරීම් (collections) තුළ int භාවිතා කළ නොහැක්කේ ඇයි?

A. Java එකතුකිරීම් (List, Map වැනි) වස්තු පමණක් හසුරවයි, ප්‍රාථමික වර්ග නොව. ඒ නිසා int වෙනුවට Integer භාවිතා කළ යුතුය.

List<Integer> list = new ArrayList<>();
list.add(123); // int is automatically converted to Integer

Q7. කාර්ය සාධනය සඳහා int හෝ Integer කුමන එක වඩා හොඳද?

A. ඉක්මන් ගණනය කිරීම හෝ ලූප් (loops) තුළ විශාල සංඛ්‍යා ප්‍රමාණයක් හසුරවීමට, int බොහෝ වේගවත් හා මතක කාර්යක්ෂමතාව වැඩි වේ. Integer වඩා පහසු සහ ලවච්චිත (flexible) වුවත්, අතිරේක වස්තු සහ බොක්සිං (boxing) නිසා බර වැඩ සඳහා අඩු සුදුසුකමක් ලබා දේ.