autoboxing

I'm implementing an interface that has functionality similar to a table that can contain an types of objects. The interface specifies the following function: double[] getDoubles(int columnIndex); Where I'm stumped is that in my implementation, I'm storing the table data in a 2D Object array ( Object[][] data ). When I need to return the values, I want to do the following (it is assumed that getDoubles() will only be called on a column that contains doubles, so there will be no ClassCastExceptions ): double[] getDoubles(int columnIndex) { return (double[]) data[columnIndex]; } But - Java doesn

The following code compiles (with Java 8): Integer i1 = 1000; int i2 = 1000; boolean compared = (i1 == i2); But what does it do? Unbox i1 : boolean compared = (i1.intvalue() == i2); or box i2 : boolean compared = (i1 == new Integer(i2)); So does it compare two Integer objects (by reference) or two int variables by value? Note that for some numbers the reference comparison will yield the correct result because the Integer class maintains an internal cache of values between -128 to 127 (see also the comment by TheLostMind). This is why I used 1000 in my example and why I specifically ask about

I noticed today that auto-boxing can sometimes cause ambiguity in method overload resolution. The simplest example appears to be this: public class Test { static void f(Object a, boolean b) {} static void f(Object a, Object b) {} static void m(int a, boolean b) { f(a,b); } } When compiled, it causes the following error: Test.java:5: reference to f is ambiguous, both method f(java.lang.Object,boolean) in Test and method f(java.lang.Object,java.lang.Object) in Test match static void m(int a, boolean b) { f(a, b); } ^ The fix to this error is trivial: just use explicit auto-boxing: static void m

Possible Duplicate: Arrays.asList() not working as it should? Apparently the return type of Arrays.asList(new int[] { 1, 2, 3 }); is List<int[]> . This seems totally broken to me. Does this have something to do with Java not autoboxing arrays of primitive types? The problem is that Arrays.asList takes a parameter of T... array . The only applicable T when you pass the int[] is int[] , as arrays of primitives will not be autoboxed to arrays of the corresponding object type (in this case Integer[] ). So you can do Arrays.asList(new Integer[] {1, 2, 3}); . Try: Arrays.asList(new Integer[] { 1, 2,

When the Java compiler autoboxes a primitive to the wrapper class, what code does it generate behind the scenes? I imagine it calls: The valueOf() method on the wrapper The wrapper's constructor Some other magic? You can use the javap tool to see for yourself. Compile the following code: public class AutoboxingTest { public static void main(String []args) { Integer a = 3; int b = a; } } To compile and disassemble: javac AutoboxingTest.java javap -c AutoboxingTest The output is: Compiled from "AutoboxingTest.java" public class AutoboxingTest extends java.lang.Object{ public AutoboxingTest();

This question is about "Why does autoboxing make some calls ambiguous in Java?" But reading through the answers, there are a number of references to casting and I'm not sure I completely understand the difference. Can someone provide a simple explanation? Boxing is when you convert a primitive type to a reference type, un-boxing is the reverse. Casting is when you want one type to be treated as another type, between primitive types and reference types this means an implicit or explicit boxing operation. Whether it needs to be explicit is a language feature. Both casting and boxing/unboxing