Boxing Integer, Short, Byte and Char

[saqib sarwar]

    
Integer ia = new Integer(100);
    Integer ib = new Integer(100);
    int ic =100;
    Integer id = 100;
    Integer ie = 100;
    out.println(ia==ib);    // false
    out.println(ia==ic);     // true
    out.println(ia==id);    // false
    out.println(ic==id);     // true
    [B]out.println(id==ie);     // true[/B]
    
    out.println("below is character code");
    Character ca = new Character('A');
    Character cb = new Character('A');
    char cc = 'A';
    Character cd = 'A';
    Character ce = 'A';
    out.println(ca==cb);    // false
    out.println(ca==cc);     // true
    out.println(ca==cd);    // false
    out.println(cc==cd);     // true
[B]    out.println(cd==ce);     // true[/B]
    
    out.println("below is boolean result");    
    Boolean ba = new Boolean(true);        
    Boolean bb = new Boolean(true);        
    boolean bc = true;        
    Boolean bd = true; 
    Boolean be = true;
    System.out.println(ba==bb);       // false
    System.out.println(ba==bc);       // true
    System.out.println(ba == bd);     // false
    System.out.println(bc == bd);     // true
    [B]System.out.println(bd == be);     // true[/B]

Can any one Explain in detail whats happening in BOLD lines.

is it comparing referance or value ?

Thanks
Saqib

[ April 12, 2007: Message edited by: saqib sarwar ]
[ April 12, 2007: Message edited by: saqib sarwar ]

[Keith Lynn]

System.out.println(bd == be);

In this line, references are being compared.

But because bd and be refer to Boolean objects created by autoboxing true, they refer to the same object.

[Steven Young]

Yes, there is a unfortunately a rule that you may have to commit to memory:

When 2 wrapper instances created through autoboxing will always be == when there primitive values are the same. This rule only applies to the following:

Boolean
Byte
Character from \u0000 to \u007f (127 in decimal)
Short from -128 to 127
Integer from -128 to 127

I believe this is because the designers of Java wanted to optimise memory management by having the references refer to the same object. Similar to the String literal pool I guess.

If anyone has a simple way of remembering this rule, please let me know. Or maybe someone may be able to explain exactly why it is only the above circumstances that apply.

[Keith Lynn]

This is from the Java Language Specification.

If the value p being boxed is true, false, a byte, a char in the range \u0000 to \u007f, or an int or short number between -128 and 127, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.

Discussion

Ideally, boxing a given primitive value p, would always yield an identical reference. In practice, this may not be feasible using existing implementation techniques. The rules above are a pragmatic compromise. The final clause above requires that certain common values always be boxed into indistinguishable objects. The implementation may cache these, lazily or eagerly.

For other values, this formulation disallows any assumptions about the identity of the boxed values on the programmer's part. This would allow (but not require) sharing of some or all of these references.

This ensures that in most common cases, the behavior will be the desired one, without imposing an undue performance penalty, especially on small devices. Less memory-limited implementations might, for example, cache all characters and shorts, as well as integers and longs in the range of -32K - +32K.

Boxing Conversion
[ April 12, 2007: Message edited by: Keith Lynn ]

[Bert Bates]

Interesting yes. Very important? I don't see how this is any more important than any of the other threads in this forum.

As a general rule, please avoid words like "importtant" or "urgent" in youir thread titles - if anything it will tend to make people avoid answering your question. Everyone here is a volunteer, and every answer is created because someone decided to spend their precious time for free!

[saqib sarwar]

Thanks Steven Young & keith Lynn For Nice explaination.

specially the background reasoning provided by keith lynn.



And for Bert Bates, "very important?" means this concept is very important for all in my point of view. Well, Bert i will try to make my Topic more a appropriate in future.

Thanks to All