boxing

I'm trying to determine whether the following statements are guaranteed to be true: ((Boolean)true) == Boolean.TRUE ((Boolean)true) == Boolean.valueOf(true) ((Integer)1) == Integer.valueOf(1) I've always assumed that autoboxing was equivalent to calling valueOf() on the corresponding type. Every discussion that I've seen on the topic seems to support my assumption. But all I could find in the JLS was the following ( §5.1.7 ): If the value p being boxed is an integer literal of type int between -128 and 127 inclusive (§3.10.1), or the boolean literal true or false (§3.10.3), or a character

Lately I've written a project in Java and noticed a very strange feature with double/Double implementation. The double type in Java has two 0's, i.e. 0.0 and -0.0 (signed zero's). The strange thing is that: 0.0 == -0.0 evaluates to true , but: new Double(0.0).equals(new Double(-0.0)) evaluates to false . Does anyone know the reason behind this? It is all explained in the javadoc : Note that in most cases, for two instances of class Double, d1 and d2, the value of d1.equals(d2) is true if and only if d1.doubleValue() == d2.doubleValue() also has the value true. However, there are two exceptions

The .NET 1.0 way of creating collection of integers (for example) was: ArrayList list = new ArrayList(); list.Add(i); /* boxing */ int j = (int)list[0]; /* unboxing */ The penalty of using this is the lack of type safety and performance due to boxing and unboxing. The .NET 2.0 way is to use generics: List<int> list = new List<int>(); list.Add(i); int j = list[0]; The price of boxing (to my understanding) is the need to create an object on the heap, copy the stack allocated integer to the new object and vice-versa for unboxing. How does the use of generics overcome this? Does the stack

Given a generic parameter TEnum which always will be an enum type, is there any way to cast from TEnum to int without boxing/unboxing? See this example code. This will box/unbox the value unnecessarily. private int Foo<TEnum>(TEnum value) where TEnum : struct // C# does not allow enum constraint { return (int) (ValueType) value; } The above C# is release-mode compiled to the following IL (note boxing and unboxing opcodes): .method public hidebysig instance int32 Foo<valuetype .ctor ([mscorlib]System.ValueType) TEnum>(!!TEnum 'value') cil managed { .maxstack 8 IL_0000: ldarg.1 IL_0001: box !

Let's imagine one retrieves the declaring type of a Field using reflection. Which of the following tests will correctly indicate whether one is dealing with an int or an Integer ? Field f = ... Class<?> c = f.getDeclaringClass(); boolean isInteger; isInteger = c.equals(Integer.class); isInteger = c.equals(Integer.TYPE); isInteger = c.equals(int.class); isInteger = ( c == Integer.class); isInteger = ( c == Integer.TYPE); isInteger = ( c == int.class); Based on Field.getType() (instead of f.getDeclaringClass() ), I get the following: Type: java.lang.Integer equals(Integer.class): true equals(int

I was just participating in Stack Overflow question Is everything in .NET an object? . And one poster (in comments of accepted answer) seemed to think that performing a method call on a value type resulted in boxing. He pointed me to Boxing and Unboxing (C# Programming Guide) which doesn't exactly specify the use case we're describing. I'm not one to trust a single source, so I just wanted to get further feedback on the question. My intuition is that there is no boxing but my intuition does suck. :D To further elaborate: The example I used was: int x = 5; string s = x.ToString(); // Boxing??

How to convert byte[] to Byte[], and also Byte[] to byte[], in the case of not using any 3rd party library? Is there a way to do it fast just using the standard library? Juvanis Byte class is a wrapper for the primitive byte . This should do the work: byte[] bytes = new byte[10]; Byte[] byteObjects = new Byte[bytes.length]; int i=0; // Associating Byte array values with bytes. (byte[] to Byte[]) for(byte b: bytes) byteObjects[i++] = b; // Autoboxing. .... int j=0; // Unboxing Byte values. (Byte[] to byte[]) for(Byte b: byteObjects) bytes[j++] = b.byteValue(); byte[] to Byte[] : byte[] bytes =