autoboxing

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

I am a java novice and so confused by the following example. Is it okay to think that "==" sign will compare the values between Integers and "autoboxed" Integers from int, and compare reference address between Integers? What about doubles and 0/0? import edu.princeton.cs.introcs.*; public class Autoboxing { public static void cmp(Integer first, Integer second) { if (first < second) StdOut.printf("%d < %d\n", first, second); else if (first == second) StdOut.printf("%d == %d\n", first, second); else if (first > second) StdOut.printf("%d > %d\n", first, second); else StdOut.printf("%d and %d are

This question already has an answer here: Weird Integer boxing in Java 10 answers public class Main { /** * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here int a1 = 1000, a2 = 1000; System.out.println(a1==a2);//=>true Integer b1 = 1000, b2 = 1000; System.out.println(b1 == b2);//=>false Integer c1 = 100, c2 = 100; System.out.println(c1 == c2);//=>true } } Why is b1 == b2 false and c1 == c2 true? Read this . Java uses a pool for Integer s in the range from -128 to 127. That means if you create an Integer with Integer i = 42;

Is this autoboxing? Object ob = 8; Will the above code first wrap the int literal 8 in an Integer and then assign its reference to variable ob? Because the java language specification has nothing on this case. Will the above code first wrap the int literal 8 in an Integer and then assign its reference to variable ob? Yes. (Or rather, it will box the int value into an Integer object, and then assign the reference to the variable ob . The fact that the integer value is a literal is irrelevant here, really. It could be a method call returning int , for example.) Because the java language

Autoboxing seems to come down to the fact that I can write: Integer i = 0; instead of: Integer i = new Integer(0); So, the compiler can automatically convert a primitive to an Object. Is that the idea? Why is this important? You kind of simplified it a little too much. Autoboxing also comes into play when using collections. As explained in sun's java docs: Collections can only hold object references, so you have to box primitive values into the appropriate wrapper class. ... When you take the object out of the collection, you get the Integer that you put in; if you need an int, you must unbox

So I was asked this question today. Integer a = 3; Integer b = 2; Integer c = 5; Integer d = a + b; System.out.println(c == d); What will this program print out? It returns true. I answered it will always print out false because of how I understood auto (and auto un) boxing. I was under the impression that assigning Integer a = 3 will create a new Integer(3) so that an == will evaluate the reference rather then the primitive value. Can anyone explain this? Peter Štibraný Boxed values between -128 to 127 are cached. Boxing uses Integer.valueOf method, which uses the cache. Values outside the

Reference: http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html "If your program tries to autounbox null, it will throw a NullPointerException." javac will give you a compile-time error if you try to assign null to a boolean. makes sense. assigning null to a Boolean is a-ok though. also makes sense, i guess. but let's think about the fact that you'll get a NPE when trying to autounbox null. what this means is that you can't safely perform boolean operations on Booleans without null-checking or exception handling. same goes for doing math operations on an Integer. for a long time,