Cómo lanzar un objeto a un int

¿Cómo puedo lanzar un objeto a un int en Java?

Si está seguro de que este objeto es un Integer:

int i = (Integer) object;

O, a partir de Java 7, puede escribir de manera equivalente:

int i = (int) object;

Cuidado, puede arrojar un ClassCastExceptionsi su objeto no es un Integery un NullPointerExceptionsi su objeto es null.

De esta manera, asume que su objeto es un entero (el int envuelto) y lo desempaqueta en un int.

intes un primitivo, por lo que no se puede almacenar como un Object, la única forma es tener un intconsiderado / encuadrado como Integerluego almacenado como un Object.

Si su objeto es un String, entonces puede usar el Integer.valueOf()método para convertirlo en un int simple:

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

Puede arrojar un NumberFormatExceptionsi su objeto no es realmente Stringun número entero como contenido.

Recursos:

• Oracle.com - Autoboxing
• Oracle.com - Tipos de datos primitivos

Sobre el mismo tema:

• Java: ¿Cuál es la diferencia entre autoboxing y casting?
• Autoboxing: Entonces puedo escribir: Entero i = 0; en lugar de: Entero i = nuevo Entero (0);
• Convertir objeto en int primitivo

Asumiendo que el objeto es un Integer objeto, puede hacer esto:

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

Si el objeto no es un Integerobjeto, debe detectar el tipo y convertirlo en función de su tipo.

Escenario 1: caso simple

Si se garantiza que su objeto es un Integer, esta es la manera simple:

int x = (Integer)yourObject;

Escenario 2: cualquier objeto numérico

En Java Integer, etc. Long, BigIntegertodos implementan la Numberinterfaz que tiene un método llamado intValue. También debe implementarse cualquier otro tipo personalizado con un aspecto numérico Number(por ejemplo:) Age implements Number. Así que puedes:

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

Escenario 3: analizar texto numérico

Cuando acepta la entrada del usuario desde la línea de comando (o campo de texto, etc.), la obtiene como a String. En este caso puedes usar Integer.parseInt(String string):

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

Si usted recibe como entrada Object, se puede utilizar (String)input, o, si se puede tener un otro tipo textual, input.toString():

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

Escenario 4: hash de identidad

En Java no hay punteros. Sin embargo, Objecttiene una implementación predeterminada similar a un puntero para hashCode(), que está directamente disponible a través de System.identityHashCode(Object o). Así que puedes:

int x = System.identityHashCode(yourObject);

Tenga en cuenta que esto no es un valor de puntero real. La dirección de memoria de los objetos puede ser cambiada por la JVM mientras se mantienen sus hashes de identidad. Además, dos objetos vivos pueden tener el mismo hash de identidad.

También puedes usar object.hashCode() , pero puede ser específico del tipo.

Escenario 5: índice único

En los mismos casos, necesita un índice único para cada objeto, como aumentar automáticamente los valores de ID en una tabla de base de datos (y a diferencia del hash de identidad que no es único). Una implementación de muestra simple para esto:

class ObjectIndexer {

    private int index = 0;

    private Map<Object, Integer> map = new WeakHashMap<>();

    public int indexFor(Object object) {
        if (map.containsKey(object)) {
            return map.get(object);
        } else {
            index++;
            map.put(object, index);
            return index;
        }
    }

}

Uso:

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

Escenario 6: miembro enum

En Java, los miembros de enumeración no son enteros, sino objetos con todas las funciones (a diferencia de C / C ++, por ejemplo). Probablemente nunca sea necesario convertir un objeto enum int, sin embargo, Java asocia automáticamente un número de índice a cada miembro enum. Se puede acceder a este índice a través de Enum.ordinal(), por ejemplo:

enum Foo { BAR, BAZ, QUX }

// ...

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

@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");
    }
}

Como puede ver, esta no es una forma muy eficiente de hacerlo. Simplemente tienes que estar seguro de qué tipo de objeto tienes. Luego conviértalo a int de la manera correcta.

Tienes que convertirlo en un entero (clase de contenedor de int). Luego puede usar el método intValue () de Integer para obtener el int interno.

Responder:

int i = ( Integer ) yourObject;

Si su objeto ya es un entero, se ejecutará sin problemas. es decir:

Object yourObject = 1;
//  cast here

o

Object yourObject = new Integer(1);
//  cast here

etc.

Si su objeto es otra cosa, primero deberá convertirlo (si es posible) a un int:

String s = "1";
Object yourObject = Integer.parseInt(s);
//  cast here

O

String s = "1";
Object yourObject = Integer.valueOf( s );
//  cast here

Yo uso una línea cuando proceso datos de GSON:

int i = object != null ? Double.valueOf(object.toString()).intValue() : 0;

Si Objectoriginalmente se creó una instancia de como Integer, entonces puede bajarlo a intusando el operador de conversión (Subtype).

Object object = new Integer(10);
int i = (Integer) object;

_{Tenga en cuenta que esto sólo funciona cuando se está utilizando al menos Java 1.5 con función autoboxing , de lo contrario se tiene que declarar icomo Integerlugar y luego llama intValue()en ella .}

Pero si inicialmente no se creó como un Integerabsoluto, entonces no se puede abatir así. Resultaría en un ClassCastExceptioncon el nombre de clase original en el mensaje. Si la toString()representación del objeto obtenida por String#valueOf()denota un número entero sintácticamente válido (por ejemplo, solo dígitos, si es necesario con un signo menos al frente), puede usar Integer#valueOf()o new Integer()para esto.

Object object = "10";
int i = Integer.valueOf(String.valueOf(object));

Ver también:

• Tutorial de herencia y casting

int i = (Integer) object; //Type is Integer.

int i = Integer.parseInt((String)object); //Type is String.

No se puede hacer An intno es un objeto, es un tipo primitivo. Puedes enviarlo a Integer y luego obtener el int.

 Integer i = (Integer) o; // throws ClassCastException if o.getClass() != Integer.class

 int num = i; //Java 1.5 or higher

No puedes An intno es un Object.

Integeres un Objectpensamiento, pero dudo que sea eso lo que quieres decir.

Si te refieres a lanzar un String a int, úsalo Integer.valueOf("123").

Sin embargo, no puede lanzar la mayoría de los otros Objetos a int, porque no tendrán un valor int. Por ejemplo, un XmlDocument no tiene valor int.

Supongo que se está preguntando por qué C o C ++ le permiten manipular un puntero de objeto como un número, pero no puede manipular una referencia de objeto en Java de la misma manera.

Las referencias a objetos en Java no son como punteros en C o C ++ ... Los punteros son básicamente enteros y puedes manipularlos como cualquier otro int. Las referencias son intencionalmente una abstracción más concreta y no pueden manipularse de la misma manera que los punteros.

int[] getAdminIDList(String tableName, String attributeName, int value) throws SQLException {
    ArrayList list = null;
    Statement statement = conn.createStatement();
    ResultSet result = statement.executeQuery("SELECT admin_id FROM " + tableName + " WHERE " + attributeName + "='" + value + "'");
    while (result.next()) {
        list.add(result.getInt(1));
    }
    statement.close();
    int id[] = new int[list.size()];
    for (int i = 0; i < id.length; i++) {
        try {
            id[i] = ((Integer) list.get(i)).intValue();
        } catch(NullPointerException ne) {
        } catch(ClassCastException ch) {}
    }
    return id;
}
// enter code here

Este código muestra por qué ArrayListes importante y por qué lo usamos. Simplemente lanzando intdesde Object. Puede ser útil.

Por ejemplo, objeto variable; hastaId

Object hastaId = session.getAttribute("hastaID");

Por ejemplo, lanzar un objeto a un int,hastaID

int hastaID=Integer.parseInt(String.valueOf(hastaId));

Consulte este código:

public class sample 
{
  public static void main(String[] args) 
  {
    Object obj=new Object();
    int a=10,b=0;
    obj=a;
    b=(int)obj;

    System.out.println("Object="+obj+"\nB="+b);
  }
}

so divide1=me.getValue()/2;

int divide1 = (Integer) me.getValue()/2;

Finalmente, se encontró la mejor implementación para su especificación.

public int tellMyNumber(Object any) {
    return 42;
}

primero verifique con la palabra clave instanceof. si es verdad, entonces tíralo.