ඕං දැන්ම කිව්වා පස්සේ කිව්වේ නෑ කියලා විතරක් කෑ ගහන්න එපා!!!

මුලින්ම කියන්න ඕනේ මම මේ Chapters කඩන විදිය මම මෙකේ පිළිවෙල සදා ගෙන එන විදිය ඒ කිව්වේ සරලව කිව්වොත් මා Java සින්හලෙන් යන Category එකේ ලියන දේවල් වල අන්තර්ගතය එහෙම නැත්තම් වෙනත් විදියකට කිව්වොත් මුලාස්ර මම හුගාක් වෙලාවට ලබා ගන්නේ kathy sierra ගේ OCPJP 1.6 පොතෙන් මම මේක මුලින්ම කිව්වේ, ඒකට හේතු කාරණා 2ක් තියන්වා පළවෙනි කාරණාව තමයි කවුරු හරි කිව්වොත් උබ මේ ලියන එවා අන්න අර පොතේ තියන්වා කියලා English වලින් තියනවා. ඔව් තියෙන්න පුලුවන් හැබැයි මම මේ ලියන සිංහල BLOG එක එකේ සිංහල version එක නෙමෙයි. 2ක, මේ ලියන සිංහල BLOG එක මගේ version එකක් එක කොහෙන්වත් Copy කරලා ගත්ත එකක් නෙමෙයි ඒක නිසා මේකේ වැරදි තියෙන්න පුලුවන්. එකෙන් කිය වෙන්නේ නෑ මෙකේ මම මේකේ වැරදි දෙවල් ලියන්වා කියලා මම එකෙන් අදහස් කලේ මෙකේ ලියන දේවල් ඔනේ කෙනෙක්ට තර්ක කරන්න පුලුවන් ඒක පිලිබද මගේ කිසි ගැටලුවක් නෑ. ( හැබයි ගොන් තර්ක නැතුව ) මම මෙහෙම කියන්නත් හේතු කාරණා 2ක් තියනවා.

1). මම සියල්ල දත් නෙමෙයි
2). මේ වන විට මාද සිටින්නේ දැනුම සොයා යන අවදියකයි එකට මම පොඩි උදාහරයක් කියන්නම්.
මම මාගේ Linkedin profile එකේ තුල JAVA Interview Questions කියලා Group එකක සාමජිකයෙක් සහ මම කාලයක සිට මේ Group එකේ දාන මා දන්න ප්රශ්න වලට පිලිතුරු දෙන කොල්ලෙක්. ඉතිං දවසක් මේ Group එකේ දානවා ප්රශ්නයක් මෙන්න මේ විදියට.

Why 128 == 128 returns false in java?

public class MainClass{
  public static void main(String[] args){
    Integer i1 = 128;
    Integer i2 = 128;
    System.out.println(i1 == i2);
  }
}

මෙකෙදී මගේ පිළිතුර එහෙම නැත්තම් තර්කය උනේ

මේ ප්රශ්නයේදී use කරලා තියෙන්නේ == Operator එක. == Operator එකෙන් Compare කරන්නේ Object එකේ Memory location එක එහෙම නැත්තම් වෙනත් විදියකට කිව්වොත් i1 සහ i2 කියන Object 2ක එකම Memory address එකටද refer වෙන්නේ කියන එක තමයි == Operator එකෙන් check කරන්නේ. එහෙම එකම memory address එකට refer වෙනව නම් output එක true කියලත් Memory address 2ක් නම් output එක false ලෙසත් දිස් වෙනවා. ඉතින් මේ ප්රශ්නයෙදි i1 සහ i2 කියන්න Integer කියන wrapper class එකෙන් හදන Object 2ක්. මේ Object 2ට heap එකේ (object හැදෙන්නේ මෙතන) හැදෙන්නේ වෙන වෙනම වෙනත් විදියටකට කිව්වොත් මේ Object 2කට memory address 2ක් තියනවා. ඉතිං අන්න ඒ හේතුව නිසා මෙකේ output එක false වෙනවා කියන එක තමයි සරලවම මගේ පිලිතුර උනේ. ඊට අමතරව මම .eqalus() එක ගැනත් එතනදි පොඩි පැහැදිලි කිරීමක් කලා. නමුත් ප්රශ්නයට අදල පිලිතුර තිබුනේ මා ඉහත සදහන් කල කොටසේ.

නමුත් මේ උදාහරණයයෙදී මා එක අතකින් නිවැරදි වන අතරම තවත් පැත්තකින් මා ජවා Integer wrapper class එක තුල මේ උදාහරණය කියවන තුරු නොදැන සිටි සිද්දාන්තය (theory) එකකට මගේ මනස විවෘර්ත කරනවා…..
එයට හේතුව පහලින් තිබෙන උදාහරණ 2ක බලන ඔබට තේරුම්ගන්න පුලුවන් වේවි.

Case 1:

public class MainClass {
    public static void main(String[] args) 
    {
        Integer i1 = 127;
         
        Integer i2 = 127;
         
        System.out.println(i1 == i2);
    }
}

OUTPUT: true

Case 2:

public class MainClass {
    public static void main(String[] args) 
    {
        Integer i1 = 128;
         
        Integer i2 = 128;
         
        System.out.println(i1 == i2);
    }
}

OUTPUT: false

මේ උදාහරණ 2ක බලන කෙනෙකුට තේරුම් ගන්න පුලුවන් මා ලබාදුන් පිලිතුරට අනුව Case 1 කියන උදාහරණයේද output එක false විය යුතුයි. නමුත් එය එසේ නොවෙයි. ඒ නිසයි මා මුලින්ම පැවසුවේ මේ උදාහණයත් සමගම මා මාගේ දැනුමද අලුත් කර ගැනීමකට ලක් උනා කියලා.
ඉතිං මා අලුත් කරගත් දැනුමද ඔබ හමුවේ දිග හරිමින් මා මාගේ මේ post එකට නැවතීමේ තිත තබන්නම්.

ඇත්තටම ඉහත Case 1 කියන උදාහරණයේ output එක false උනේ කෙසේද?

ඔබ කොයි වේලාවකදි හරි Integer Wrapper Class එකකින් Object Create කරන කොට එය Auto boxing කියන ක්‍රියාවලියකට ලක් වෙනවා මෙහිදී Java Compiler විසින් ඔබ ලියු මෙම පේලිය “Integer i1 = 127” නැවත ලියනවා මෙන්න මේ විදියට

Integer i1 = Integer.valueOf(127);

මේ Integer.valueOf() එක ඇතුලේ Parameter එකක් විදියට අපි pass කරන value එකට අදාලව හදනවා අලුත් Object එකක්. ඒත් ඇත්තටම මේ method එක ඔබ pass කරන හැම value එකකටම අලුත් object එකක් හදන්නේ නෑ. එකට හේතුව තමයි මේ method එක එකතරා විශේශිත Number Range එකක තියන values ටිකක් එයා ලග තියාගෙන ඉන්නවා එහෙම නැත්තම් වෙනත් විදියකට කිව්වොත් Cached කරලා තියාගෙන ඉන්නවා. මේ range එක තමයි -128 ඉදන් 127 වෙනකන් (127 ඇතුලත් ව ) ඉතින් මෙන්න මේ Range එකේ ඇතුලේ එන ඕනෑම value එකකට අර Integer.valueOf() කියන static method එක ඇතුලෙදි අලුත් Object එකක් create වෙන්නේ නෑ. හැබැයි මේ range එකෙන් පිට එන හැම value එකකටම Integer class ඇතුලෙදි අලුත් Object එකක් create වෙනවා.

මෙන්න මේ දේ මම දැන ගත්තේත් මෑතකදී ඉතින් මෙන්න මේ හේතුව නිසා තමයි මම මේ post එක මුලදිම කිව්වේ මාගේ post සම්බන්දයෙන් තර්ක විතර්ක ඕනෑම කෙනෙකුට නගන්න පුලුවන් ඒ පිලිබද කිසිදු ගැටලුවක් මා සතුව නෑ කියලා ඉතිං මේ post ටුවට නැවතීමේ තිත තබන්න ප්රථමයෙන් පහලින් මම පෙන්නලා දිලා තියෙන්න Integer class එක ඇතුලේ තියන static method එකක් වෙන valueOf method එක ලියා ඇති ආකාරය සහ ඉන්පසුව පෙන්වා දී ඇත්තේ IntegerCache Class එක ලියා ඇති ආකාරයයි. (මෙවා මම ලියපුවා නෙමෙයි Java වල Inbuild ලියලා තියන එවා :p )

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache Class:

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
 
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127;
        }
 
        private IntegerCache() {}
    }

පසු වදන :-
මේ post එකේ මම මගේ වාග් චාතූර්ය ලිවිමට හැරවිමේදී මාගේ වෙනත් post වලට සාපේක්ශව මාහප්ප්රාණ වචන යොදා ගත් අතර එය එසේ ලිව්වේ හැමදාම එකම ආකාරය ලියා ඇති වී කර වී එපා වී ඇති හේතුව නිසා බවත් නැතුව මාගේ පොරත්වය පිලිබිබු නොකිරිමට නොවන බවත් මෙයින් ප්රකාශ කිරිමට කැමැත්තෙමි. තවද මෙම ලිපියෙහි බොහො දෑ ඔබ මේ මොහොත වන විට නොදැන සිටිමට පුලුවන උදාහණයක් ලෙස Auto Boxing වැනි දෑ… මේ පිලිබද කණගාටු නොවන ලෙසත් ඔබට කණගාටුවක් දැනෙන්නේ නම් සතෙන් සතේ රුපියලෙන් යන අප පොඩි කාලේ නැරඹු Advertisement එක සිහියට ගෙන එය ආදර්ශයට ගන්නා ලෙසත් අවසාන වශයෙන් ලියා නවතිමි.