How to cast an Object to an int

How can I cast an Object to an int in java?

If you're sure that this object is an Integer :

int i = (Integer) object;

Or, starting from Java 7, you can equivalently write:

int i = (int) object;

Beware, it can throw a ClassCastException if your object isn't an Integer and a NullPointerException if your object is null.

This way you assume that your Object is an Integer (the wrapped int) and you unbox it into an int.

int is a primitive so it can't be stored as an Object, the only way is to have an int considered/boxed as an Integer then stored as an Object.

If your object is a String, then you can use the Integer.valueOf() method to convert it into a simple int :

int i = Integer.valueOf((String) object);

It can throw a NumberFormatException if your object isn't really a String with an integer as content.

Resources :

• Oracle.com - Autoboxing
• Oracle.com - Primitive Data types

On the same topic :

• Java: What's the difference between autoboxing and casting?
• Autoboxing: So I can write: Integer i = 0; instead of: Integer i = new Integer(0);
• Convert Object into primitive int

Scenario 1: simple case

If it's guaranteed that your object is an Integer, this is the simple way:

int x = (Integer)yourObject;

Scenario 2: any numerical object

In Java Integer, Long, BigInteger etc. all implement the Number interface which has a method named intValue. Any other custom types with a numerical aspect should also implement Number (for example: Age implements Number). So you can:

int x = ((Number)yourObject).intValue();

Scenario 3: parse numerical text

When you accept user input from command line (or text field etc.) you get it as a String. In this case you can use Integer.parseInt(String string):

String input = someBuffer.readLine();
int x = Integer.parseInt(input);

If you get input as Object, you can use (String)input, or, if it can have an other textual type, input.toString():

int x = Integer.parseInt(input.toString());

Scenario 4: identity hash

In Java there are no pointers. However Object has a pointer-like default implementation for hashCode(), which is directly available via System.identityHashCode(Object o). So you can:

int x = System.identityHashCode(yourObject);

Note that this is not a real pointer value. Objects' memory address can be changed by the JVM while their identity hashes are keeping. Also, two living objects can have the same identity hash.

You can also use object.hashCode(), but it can be type specific.

Scenario 5: unique index

In same cases you need a unique index for each object, like to auto incremented ID values in a database table (and unlike to identity hash which is not unique). A simple sample implementation for this:

class ObjectIndexer {
    
    private int index = 0;
    
    private Map<Object, Integer> map = new WeakHashMap<>();
    //                               or:
    //                                 new WeakIdentityHashMap<>();
    
    public int indexFor(Object object) {
        if (map.containsKey(object)) {
            return map.get(object);
        } else {
            index++;
            map.put(object, index);
            return index;
        }
    }
    
}

Usage:

ObjectIndexer indexer = new ObjectIndexer();
int x = indexer.indexFor(yourObject);    // 1
int y = indexer.indexFor(new Object());  // 2
int z = indexer.indexFor(yourObject);    // 1

Scenario 6: enum member

In Java enum members aren't integers but full featured objects (unlike C/C++, for example). Probably there is never a need to convert an enum object to int, however Java automatically associates an index number to each enum member. This index can be accessed via Enum.ordinal(), for example:

enum Foo { BAR, BAZ, QUX }

// ...

Object baz = Foo.BAZ;
int index = ((Enum)baz).ordinal(); // 1

Assuming the object is an Integer object, then you can do this:

int i = ((Integer) obj).intValue();

If the object isn't an Integer object, then you have to detect the type and convert it based on its type.

@Deprecated
public static int toInt(Object obj)
{
    if (obj instanceof String)
    {
         return Integer.parseInt((String) obj);
    } else if (obj instanceof Number)
    {
         return ((Number) obj).intValue();
    } else
    {
         String toString = obj.toString();
         if (toString.matches("-?\d+"))
         {
              return Integer.parseInt(toString);
         }
         throw new IllegalArgumentException("This Object doesn't represent an int");
    }
}

As you can see, this isn't a very efficient way of doing it. You simply have to be sure of what kind of object you have. Then convert it to an int the right way.

You have to cast it to an Integer (int's wrapper class). You can then use Integer's intValue() method to obtain the inner int.