It looks like the language in section 5.5 Casting Conversion of Java 7 JLS was updated in comparison to the same section in the Java 5/6 JLS, probably to clarify the allowed conversions. Java 7 JLS says An expression of a reference type may undergo casting conversion to a primitive type without error, by unboxing … Read more
The problem is that you don’t cast an object to an int, you’re attempting to unbox an int. The object really has to be an int. It cannot be just anything that can be converted to an int. So the difference is that this: int a = (int)obj; Really needs obj to be a boxed … Read more
Boxing refers to a conversion of a non-nullable-value type into a reference type or the conversion of a value type to some interface that it implements (say int to IComparable<int>). Further, the conversion of an underlying value type to a nullable type is also a boxing conversion. (Caveat: Most discussions of this subject will ignore … Read more
If you need different behaviour when you’re dealing with a value-type then you’re obviously going to need to perform some kind of test. You don’t need an explicit check for boxed value-types, since all value-types will be boxed** due to the parameter being typed as object. This code should meet your stated criteria: If value … Read more
The compiler will consider not a downcast, but an unboxing conversion for overload resolution. Here, the Integer i will be unboxed to an int successfully. The String method isn’t considered because an Integer cannot be widened to a String. The only possible overload is the one that considers unboxing, so 8 is printed. The reason … Read more
You can only unbox a value type to its original type (and the nullable version of that type). By the way, this is valid (just a shorthand for your two line version): object i = 4; decimal d = (decimal)(int)i; // works even w/o decimal as it’s a widening conversion For the reason behind this … Read more
Clearly the machine code the JIT compiler can generate for the first case is much more efficient. One rule that really helps there is that an object can only be unboxed to a variable that has the same type as the boxed value. That allows the JIT compiler to generate very efficient code, no value … Read more
Because of this code in Integer.valueOf(int): public static Integer valueOf(int i) { if(i >= -128 && i <= IntegerCache.high) return IntegerCache.cache[i + 128]; else return new Integer(i); } Explanation: Integer integer1 = 127 is a shortcut for Integer integer1 = Integer.valueOf(127), and for values between -128 and 127 (inclusive), the Integers are put in a … Read more
Boxed values are data structures that are minimal wrappers around primitive types*. Boxed values are typically stored as pointers to objects on the heap. Thus, boxed values use more memory and take at minimum two memory lookups to access: once to get the pointer, and another to follow that pointer to the primitive. Obviously this … Read more
When in doubt, check the bytecode: Integer n = 42; becomes: 0: bipush 42 2: invokestatic #16 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 5: astore_1 So in actuality, valueOf() is used as opposed to the constructor (and the same goes for the other wrapper classes). This is beneficial since it allows for caching, and doesn’t force the creation … Read more