classes Wrapper

[Bruno Sant Ana]

Hi guys,

I'm studying to get a Java certificate, therefore I'm reading Kathy Sierra's book. On page 135 I found something that appears very strange to me. First I declare two Integer objects(i1 and i2) and compare both of them using != and after that using equals. The output says that they are different objects but meaningfully equal. In the second part of the code I create two Integer objects(i3 and i4) and compare them using == and equal. It seems that i3 and i4 are the same object(at least the output says that), but it isn't true in my point of view, and I don't understand why i1 and i2 are different and i3 and i4 are the same. What mess in my head. Does anybody help me to understand this code bellow? Thanks and sorry my bad english.

package boxing;

public class BoxingWrapper {
	static public void main(String[] args){
		Integer i1 = 1000;
		Integer i2 = 1000;
		
		if(i1 != i2){
			System.out.println("different objects");
		}
		
		if(i1.equals(i2)){
			System.out.println("meaningfully equal");
		}
		
		Integer i3 = 10;
		Integer i4 = 10;
		
		if(i3 == i4){
			System.out.println("same object");
		}
		
		if(i3.equals(i4)){
			System.out.println("meaningfully equal");
		}
	}
}

[Jeff Verdegan]

When you assign a primitive to an wrapper class, such as Integer i = 123, that's autoboxing. The compiler inserts a call to Integer.valueOf(123), this, in turn, may create a new Object, or may simply return a reference to an object in the constant pool. The default for the constant pool is integers in the range -128..127, however, it can be configured at JVM startup with a command line parameter.

So, when you autobox an int in the range -128..127, you get an object from the pool, so the same int value there gets mapped to the same single Integer object. And when you autobox an int outside that range, a new Integer object is created each time.

HOWEVER, if you write your Java code correctly, you'll never need to know this. That is, if you want to see if two objects hold the same "contents" or "value", you must always use equals(). When you do that correctly, it won't ever matter whether the objects were cached or not.

The only time to use == is when you want to see if two references point to the same object, and there are not many use cases where that arises. The main one is as a shortcut in implementing equals()--the first step is often if (that == this) reutrn true; Other than that, there are precious few occasions when it is correct to use == for reference types.

[dennis deems]

Integer objects whose values are between -128 and 127 are cached. When a value is assigned to an Integer reference, if the value is cached then that will be used instead of creating a redundant object. You can defeat this by using the "new" keyword: Integer i5 = new Integer( 10 ) always creates a new object even if an Integer with value 10 already exists.

Edit: too slow.

[Rob Spoor]

Welcome to the Ranch, Bruno!

Could you please SearchFirst next time? This exact same question has been asked several times before.

[Bruno Sant Ana]

Hey,

Thanks Jeff and Dennis, I think I understood this matter.

Rob, I should have searched before posting, I'm sorry. Here is the code that I used to test and I think it can help others. Guys, please just review my code and the comments that I added to it and if it's correct I'll be happy in closing this post:

public class BoxingWrapper {  
    static public void main(String[] args){ 
        //int -> from −2147483648 to 2147483647
        //creating new objects because int's are out of range -128 to 127
        Integer i1 = -129;  
        Integer i2 = -129;  
          
        if(i1 == i2){  
            System.out.println("same objects");  
        }else{
            System.out.println("different objects");  
        }
        
        Integer i3 = 128;  
        Integer i4 = 128;  
          
        if(i3 == i4){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
        
        Integer i5 = -2147483648;  
        Integer i6 = -2147483648;
        
        if(i5 == i6){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
        
        Integer i7 = 2147483647;  
        Integer i8 = 2147483647;
        
        if(i7 == i8){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
          
        //getting objects from constant pool between -128 and 127
        Integer i9 = -128;
        Integer i10 = -128;  
          
        if(i9 == i10){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
        
        Integer i13 = 100;  
        Integer i14= 100;  
          
        if(i13 == i14){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
        
        Integer i11 = 127;  
        Integer i12= 127;  
          
        if(i11 == i12){  
            System.out.println("same object");  
        }else{
            System.out.println("different objects");  
        }
    }  
}  

The output is like that:


different objects
different objects
different objects
different objects
same object
same object
same object

[Campbell Ritchie]

If you look in the Java Language specification (JLS) and the Integer class, you will find about wrapper class caching. Note that it does not say that values between -128 and +127 are cached, if you read the small print in the JLS.

[Rob Spoor]

But the Javadoc of Integer.valueOf(int) does:

This method will always cache values in the range -128 to 127, inclusive, and may cache other values outside of this range.

[fixed typo]

[Campbell Ritchie]

No, it doesn’t say “-128 to 127”. It says “-128 to 127 and maybe more”.
I was a bit imprecise in what I said yesterday.

[Rob Spoor]

Let's just agree that I've misinterpreted what you were trying to say.

[Campbell Ritchie]

And let’s agree that I didn’t say it at all clearly. Sorry.

[Rob Spoor]

You're forgiven

[Campbell Ritchie]