Java: Integer value comparison

Question

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?

Answer 1

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 autoboxing¹:

  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).

¹Technically, 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.

Answer 2

Integers are autounboxed, so you can just do

if (count > 0) {
    .... 
}

Answer 3

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) { }

Answer 4

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.

Answer 5

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)