# Tutorial :Integer value comparison ### Question:

I'm a newbie Java coder and I just read a variable of an integer class can be described three 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 to 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 right? Is there a value comparison operator where its just `count=0`?

### Solution:1

Integers are autounboxed, so you can just do

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

### Solution:2

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.

### Solution:3

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

For one thing, it's a bit slower than `int < int`, 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 `NullPointerException`.

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.

### Solution:4

You can also use equals:

`` Integer a = 0;     if (a.equals(0)) {       // a == 0   }  ``

which is equivalent to:

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

and also:

`` if (a == 0) {     }  ``

(the Java compiler automatically adds intValue())

Note that autoboxing/autounboxing can introduce a significant overhead (especially inside loops).

### Solution:5

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

### Solution:6

One more thing to watch out for is if the second value was another Integer object instead of a literal '0', the '==' operator compares the object pointers and will not auto-unbox.

ie:

``Integer a = new Integer(0);     Integer b = new Integer(0);     int c = 0;    boolean isSame_EqOperator = (a==b); //false!  boolean isSame_EqMethod = (a.equals(b)); //true  boolean isSame_EqAutoUnbox = ((a==c) && (a.equals(c)); //also true, because of auto-unbox    //Note: for initializing a and b, the Integer constructor   // is called explicitly to avoid integer object caching   // for the purpose of the example.  // Calling it explicitly ensures each integer is created   // as a separate object as intended.  // Edited in response to comment by @nolith  ``

### Solution:7

well i might be late on this but i would like to share something:

Given the input: System.out.println(isGreaterThanZero(-1));

``public static boolean isGreaterThanZero(Integer value) {      return value == null?false:value.compareTo(0) > 0;  }  ``

Returns false

``public static boolean isGreaterThanZero(Integer value) {      return value == null?false:value.intValue() > 0;  }  ``

Returns true So i think in yourcase 'compareTo' will be more accurate.

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »