views:

4533

answers:

5

I'm a newbie Java coder and I just read a variable of an integer class can be described 3 different ways in the api. I have the following code..

if (count.compareTo(0)) { 
            System.out.println(out_table);
            count++;
    }

This is inside a loop and just outputs out_table.
My goal is the figure out how to see if the value in integer count > 0

I realize the count.compare(0) is the correct way? or is it count.equals(0)?

I know the count == 0 is incorrect. Is this correct? Is there a value comparison operator where its just count=0?

+5  A: 

To figure out if an Integer is greater than 0, you can:

  • check if compareTo(O) returns a positive number:

    if (count.compareTo(0) > 0)
         ...
    

    But that looks pretty silly, doesn't it? Better just...

  • use autoboxing1:

    if (count > 0)
        ....
    

    This is equivalent to:

    if (count.intValue() > 0)
        ...
    

    It is important to note that "==" is evaluated like this, with the Integer operand unboxed rather than the int operand boxed. Otherwise, count == 0 would return false when count was initialized as new Integer(0) (because "==" tests for reference equality).

1Technically, the first example uses autoboxing (before Java 1.5 you couldn't pass an int to compareTo) and the second example uses unboxing. The combined feature is often simply called "autoboxing" for short, which is often then extended into calling both types of conversions "autoboxing". I apologize for my lax usage of terminology.

Michael Myers
The former example is using autoboxing; the latter autounboxing.
Tom Hawtin - tackline
Yeah, I was a little sloppy. I've added a note of explanation.
Michael Myers
+1: Regarding the `==` comparison, one should be very cautious when comparing *two* *boxed* numbers (but not one boxed and one primitive number), because, as mmyers mentioned, `==` tests for reference equality, not equality of the wrapped values.
Christian Semrau
+5  A: 

Integers are autounboxed, so you can just do

if (count > 0) {
    .... 
}
Nathaniel Flath
Same mistake as mmyers. This is autounboxing.
Tom Hawtin - tackline
yeah, my bad. fixed that.
Nathaniel Flath
+2  A: 

Although you could certainly use the compareTo method on an Integer instance, it's not clear when reading the code, so you should probably avoid doing so.

Java allows you to use autoboxing (see http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html) to compare directly with an int, so you can do:

if (count > 0) { }

And the Integer instance count gets automatically converted to an int for the comparison.

If you're having trouble understanding this, check out the link above, or imagine it's doing this:

if (count.intValue() > 0) { }
jpdaigle
up vote for informative links.Keep in mind that `count` has to be non-null. The Exception produced at runtime auto-unboxing a null value is confusing.
Chadwick
+1  A: 

It's better to avoid unnecessary autoboxing for 2 reasons.

For one thing, it's a bit slower, as you're (sometimes) creating an extra object;

void doSomethingWith(Integer integerObject){ ...

int i = 1000;
doSomethingWith(i);//gets compiled into  doSomethingWith(Integer.valueOf(i));

The bigger issue is that hidden autoboxing can hide exceptions:

void doSomethingWith (Integer count){
 if (count>0)  // gets compiled into count.intValue()>0

Calling this method with null will throw a NullPointer.

The split between primitives and wrapper objects in java was always described as a kludge for speed. Autoboxing almost hides this, but not quite - it's cleaner just to keep track of the type. So if you've got an Integer object, you can just call compare() or intValue(), and if you've got the primitive just check the value directly.

Steve B.
+1 For mentioning the negative sides of autounboxing. The performance difference can be huge, especially when auto(un)boxing in loops.
Helper Method
+1  A: 

in addition to other answers you should use equals:

 Integer a = 0;

 if (a.equals(0)) {
     // a == 0
 }

same of:

 if (a.intValue() == 0) {
     // a == 0
 }

that is the same of:

 if (a == 0) {

 }

(the Java compiler adds automatically intValue())

NB beware autoboxing/autounboxing because they can introduce a significative overhead (especially inside loops)

dfa
0.equals(a) doesn't compile. Or were you saying not to use it?
Michael Myers
fixed, thanks :-)
dfa