Check If an Int Value Is Greater or Equal to Another Int? Value

Check if an Int value is greater or equal to another Int? value?

Because limit is an optional Int (Int?) it may be nil and not directly comparable with current. So first unwrap the optional to detect and avoid handle nil cases, and only compare non-nil cases.

if let limit = self.limit, current >= limit {
    value = amount
} else {
    value = current * 10 + amount
    if value > self.max! {
        value = amount
    }
}

Integer value comparison

Integers are autounboxed, so you can just do

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

How can I check if a value is of type Integer?

If input value can be in numeric form other than integer , check by

if (x == (int)x)
{
   // Number is integer
}

If string value is being passed , use Integer.parseInt(string_var).
Please ensure error handling using try catch in case conversion fails.

if (object == int)

The == operator you are calling is the overload that takes two object parameters. This uses reference equality - the value isn't important, it has to be the same object.

As you can read in the documentation:

For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.

While int is a value type, it has been 'boxed' (wrapped in an object). You are comparing the two different reference types that wrap your integers.

To fix this, you can use object.Equals instead - this will compare the two integers.

item.Equals(value);

Or the static method (which would handle the case where item == null):

object.Equals(item, value);

If you unbox to int then you can use the int overload of == as you expect:

(int)item == (int)value;

Again, per the docs:

For predefined value types, the equality operator (==) returns true if the values of its operands are equal.

Is it safe to compare two `Integer` values with `==` in Java?

No, it's not the right way to compare the Integer objects. You should use Integer.equals() or Integer.compareTo() method.

By default JVM will cache the Integer values from [-128, 127] range (see java.lang.Integer.IntegerCache.high property) but other values won't be cached:

Integer x = 5000;
Integer y = 5000;
System.out.println(x == y); // false

Unboxing to int or calling Integer.intValue() will create an int primitive that can be safely compared with == operator. However unboxing a null will result in NullPointerException.

Bithacks: Determine whether value is less, greater, or equal to some value

The following expression will do what you want.

1 + (x >= y) + (x > y)

On x86-64 this compiles to a fairly-efficient code using SETcc instead of branches:

compare(int, int):
    xorl    %edx, %edx
    cmpl    %esi, %edi
    setg    %al
    setge   %dl
    movzbl  %al, %eax
    leal    1(%rdx,%rax), %eax
    ret

On ARM:

compare(int, int):
    cmp r0, r1
    ite lt
    movlt   r0, #1
    movge   r0, #2
    it  gt
    addgt   r0, r0, #1
    bx  lr

Python Verifying if input is int and greater than 0

You need to convert input to an integer and then check that value. Since the user may input garbage, you have to handle the integer conversion by catching a value exception.

def get_amount():
    while True:
        amount = input("Enter amount: ")
        try:
            val = int(amount)
            if val >= 0:
                break
            else:
                print("Amount can't be negative, try again")
        except ValueError:
            print("Amount must be a number, try again")
    return val

Why Java does not see that Integers are equal?

Check out this article: Boxed values and equality

When comparing wrapper types such as Integers, Longs or Booleans using == or !=, you're comparing them as references, not as values.

If two variables point at different objects, they will not == each other, even if the objects represent the same value.

Example: Comparing different Integer objects using == and !=.

Integer i = new Integer(10);
Integer j = new Integer(10);
System.out.println(i == j); // false
System.out.println(i != j); // true

The solution is to compare the values using .equals()…

Example: Compare objects using .equals(…)

Integer i = new Integer(10);
Integer j = new Integer(10);
System.out.println(i.equals(j)); // true

…or to unbox the operands explicitly.

Example: Force unboxing by casting:

Integer i = new Integer(10);
Integer j = new Integer(10);
System.out.println((int) i == (int) j); // true

References / further reading

• Java: Boxed values and equality
• Java: Primitives vs Objects and References
• Java: Wrapper Types
• Java: Autoboxing and unboxing

---

Related Topics