cast - java integer part of double

Cast Double to Integer en Java

Question

Cualquier forma de lanzar java.lang.Double a java.lang.Integer ?

Lanza una excepción.

"java.lang.ClassCastException: java.lang.Double incompatible con java.lang.Integer"

Answer 1

Creo que es imposible entender las otras respuestas sin cubrir los escollos y razonar detrás de ellas.

No puedes lanzar directamente un Integer a un objeto Double . Además, Double y Integer son objetos inmutables, por lo que no puede modificarlos de ninguna manera. Sin embargo, cada clase numérica tiene una alternativa primitiva ( Double vs double , Integer vs int , ...).

Tenga en cuenta que estas primitivas comienzan con un carácter en minúscula (por ejemplo, int ), que en realidad nos dice que no son clases / objetos. Lo que también significa que no tienen métodos.

Estrategia:

Para convertir un Double en un Integer necesitarías seguir esta estrategia:

1. Convertir el objeto Double en un double primitivo. (= "unboxing")
2. Convertir el primitivo double a un primitivo int . (= "casting")
3. Convertir el int primitivo de nuevo a un objeto Integer . (= "boxeo")

En codigo:

// starting point
Double myDouble = Double.valueOf(10.0);

// step 1: unboxing
double dbl = myDouble.doubleValue();

// step 2: casting
int intgr = (int) dbl;

// step 3: boxing
Integer val = Integer.valueOf(intgr);

En realidad hay un atajo. Puede desempaquetar inmediatamente de un Double directo a un int primitivo. De esa manera, puedes saltarte el paso 2 por completo.

Double myDouble = Double.valueOf(10.0);
Integer val = Integer.valueOf(myDouble.intValue()); // the simple way

Escollos:

Sin embargo, hay muchas cosas que no están cubiertas en el código anterior. El código anterior no es seguro para nulos.

Double myDouble = null;
Integer val = Integer.valueOf(myDouble.intValue()); // will throw a NullPointerException

// a null-safe solution:
Integer val = (myDouble == null)? null : Integer.valueOf(myDouble.intValue());

Ahora funciona bien para la mayoría de los valores. Sin embargo, los enteros tienen un rango muy pequeño (valor mínimo / máximo) en comparación con un Double . Además de eso, los dobles también pueden contener "valores especiales", que los enteros no pueden:

• 1/0 = + infinito
• -1/0 = -infinito
• 0/0 = no definido (NaN)

Por lo tanto, dependiendo de la aplicación, es posible que desee agregar algunos filtros para evitar Excepciones desagradables.

Entonces, el siguiente defecto es la estrategia de redondeo. Por defecto Java siempre redondeará hacia abajo. Redondear hacia abajo tiene mucho sentido en todos los lenguajes de programación. Básicamente, Java está simplemente tirando algunos de los bytes. En las aplicaciones financieras, seguramente querrá usar redondeo medio arriba (por ejemplo: round(0.5) = 1 y round(0.4) = 0 ).

// null-safe and with better rounding
long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = Integer.valueOf(rounded);

Auto- (des) boxeo

Podría estar tentado a usar el auto-(un)boxing en esto, pero no lo haría. Si ya estás atascado ahora, entonces los siguientes ejemplos tampoco serán tan obvios. Si no comprende el funcionamiento interno del auto- (des) boxeo, no lo use.

Integer val1 = 10; // works
Integer val2 = 10.0; // doesn''t work

Double val3 = 10; // doesn''t work
Double val4 = 10.0; // works

Double val5 = null; 
double val6 = val5; // doesn''t work (throws a NullPointerException)

Supongo que lo siguiente no debería ser una sorpresa. Pero si es así, entonces es posible que desee leer algún artículo sobre el lanzamiento en Java.

double val7 = (double) 10; // works
Double val8 = (Double) Integer.valueOf(10); // doesn''t work
Integer val9 = (Integer) 9; // pure nonsense

Prefiero valueOf:

Además, no se sienta tentado a usar el new Integer() constructor new Integer() (como proponen otras respuestas). Los métodos valueOf() son mejores porque usan el almacenamiento en caché. Es un buen hábito usar estos métodos, porque de vez en cuando le ahorrarán algo de memoria.

long rounded = (myDouble == null)? 0L: Math.round(myDouble.doubleValue());
Integer val = new Integer(rounded); // waste of memory

Answer 2

De hecho, la forma más sencilla es usar intValue() . Sin embargo, esto simplemente devuelve la parte entera; No hace ningún redondeo. Si desea que el entero sea el más cercano al valor Doble, deberá hacer esto:

Integer integer = Integer.valueOf((int) Math.round(myDouble)));

Y no olvides el caso nulo:

Integer integer = myDouble == null ? null : Integer.valueOf((int) Math.round(myDouble)));

Math.round() maneja casos de pato impares, como infinito y NaN, con relativa gracia.

Answer 3

Debe obtener explícitamente el valor int utilizando el método intValue () de la siguiente manera:

Double d = 5.25;
Integer i = d.intValue(); // i becomes 5

O

double d = 5.25;
int i = (int) d;

Answer 4

Double y Integer son clases de envoltorio para primitivas de Java para double e int respectivamente. Puedes lanzar entre ellos, pero perderás el punto flotante. Es decir, 5.4 a un int será 5. Si lo devuelve, será 5.0.

Answer 5

Ha funcionado para mí. Prueba esto:

double od = Double.parseDouble("1.15");
int oi = (int) od;

Answer 6

Llame a intValue() en su objeto Double .

Answer 7

Me gusta esto:

Double foo = 123.456;
Integer bar = foo.intValue();

Answer 8

Memoria eficiente, ya que compartirá la instancia ya creada de Double.

Double.valueOf(Math.floor(54644546464/60*60*24*365)).intValue()

Answer 9

Prueba este

double doubleValue = 6.5;Double doubleObj = new Double(doubleValue);int intResult = doubleObj.intValue();

Answer 10

Puede hacerlo usando "Conversión de tipo Reducción o Explícita", doble → largo → int. Espero que funcione.

double d = 100.04;
long l = (long)d; // Explicit type casting required
int i = (int)l;    // Explicit type casting required

PS: Dará 0 ya que el doble tiene todos los valores decimales y nada en el lado izquierdo. En el caso de 0.58, lo reducirá a 0. Pero para otros hará la magia.

Answer 11

Simplemente hazlo de esta manera ...

Double d = 13.5578;
int i = d.intValue();
System.out.println(i);

Answer 12

Simplemente use el método intValue de Double

Double initialValue = 7.12;
int finalValue = initialValue.intValue();

Answer 13

Un Double no es un Integer , por lo que el reparto no funcionará. Note la diferencia entre la clase Double y la double primitiva . También tenga en cuenta que un Double es un Number , por lo que tiene el método intValue , que puede utilizar para obtener el valor como un int primitivo.

Answer 14

Utilice el doubleNumber.intValue(); método.

Answer 15

Veo tres posibilidades. Los dos primeros cortan los dígitos, el último se redondea al entero más cercano.

double d = 9.5;
int i = (int)d;
//i = 9

Double D = 9.5;
int i = Integer.valueOf(D.intValue());
//i = 9

double d = 9.5;
Long L = Math.round(d);
int i = Integer.valueOf(L.intValue());
//i = 10

Answer 16

Double d = 100.00;
Integer i = d.intValue();

También hay que añadir que funciona con autoboxing.

De lo contrario, obtienes un int (primitivo) y luego puedes obtener un entero desde allí:

Integer i = new Integer(d.intValue());

Answer 17

double a = 13.34;
int b = (int) a;

System.out.println(b); //prints 13