Fundido doble a entero en Java

¿Alguna 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”

Un Double no es un Integer , entonces el lanzamiento no funcionará. Tenga en cuenta la diferencia entre la clase Double y la primitiva double . También tenga en cuenta que un Double es un Number , por lo que tiene el método intValue , cuando puede usarlo para obtener un int . Primitivo.

Necesitas obtener explícitamente el valor int usando el método intValue () como este:

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

O

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

Veo tres posibilidades. Los dos primeros cortan los dígitos, el último 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 

Creo que es imposible entender las otras respuestas sin cubrir las trampas y el razonamiento detrás de esto.

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

Tenga en cuenta que estas primitivas comienzan con un carácter en minúsculas (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ía seguir esta estrategia:

  1. Convierte el objeto Double en un double primitivo. (= “unboxing”)
  2. Convierta el primitivo double en un primitivo int . (= “casting”)
  3. Convierte la primitiva int 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. Puedes unbox inmediatamente de una Double recta a una primitiva int . De esta forma, puede omitir 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 nulo seguro.

 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 = -infinity
  • 0/0 = indefinido (NaN)

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

Entonces, la próxima deficiencia es la estrategia de redondeo. Por defecto, Java siempre redondeará hacia abajo. Redondear tiene mucho sentido en todos los lenguajes de progtwigción. Básicamente Java simplemente está descartando algunos de los bytes. En aplicaciones financieras, seguramente querrá utilizar el redondeo de la mitad hacia 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 (un) boxeo

Podría sentirse tentado de usar auto- (un) boxing en esto, pero yo no lo haría. Si ya estás estancado ahora, los próximos ejemplos tampoco serán tan obvios. Si no comprende el funcionamiento interno del auto (un) 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 moldeado en Java.

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

Prefiere el valor de:

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 utilizar estos métodos, porque de vez en cuando te ahorrarán un poco de memoria.

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

De hecho, la forma más simple es usar intValue() . Sin embargo, esto simplemente devuelve la parte entera; no hace ningún redondeo. Si desea el número entero más cercano al valor doble, tendrá que 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.

Me gusta esto:

 Double foo = 123.456; Integer bar = foo.intValue(); 
 double a = 13.34; int b = (int) a; System.out.println(b); //prints 13 
 Double d = 100.00; Integer i = d.intValue(); 

También se debe agregar 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()); 

Simplemente hazlo de esta manera …

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

Llame a intValue() en su objeto Double .

Puede hacerlo utilizando “Conversión de tipo explícita o de estrechamiento”, double → long → int. Espero que funcione.

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

PD: 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.

Prueba este

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

El doble y el entero son clases de envoltura para primitivas de Java para el doble y el int respectivamente. Puedes lanzar entre ellos, pero perderás el punto flotante. Es decir, 5.4 lanzado a un int será 5. Si lo rechaza, será 5.0.

Simplemente use el método intValue de Double

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

Use doubleNumber.intValue(); método.

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

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

Me funcionó. Prueba esto:

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