Convertir doble a entero en Java

Te traemos el resultado a esta duda, al menos eso pensamos. Si continuas con dudas dínoslo, que con gusto te responderemos

Solución:

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

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

O

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

A Double no es un Integer, por lo que el yeso no funcionará. Nótese la diferencia entre el Doubleclase y el doubleprimitivo. También tenga en cuenta que un Double es un Numberentonces tiene el método intValueque puede usar para obtener el valor como un primitivo int.

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

No puedes lanzar directamente un Integer a un Double objeto. también Double y Integer son objetos inmutables, por lo que no puede modificarlos de ninguna manera.

Cada numérico clase tiene un primitivo alternativa (Double contra double, Integer contra int, …). Tenga en cuenta que estas primitivas comienzan con un carácter en minúscula (p. ej. int). Eso nos dice que no son clases/objetos. Lo que también significa que no tienen métodos. Por el contrario, las clases (p. ej. Integer) actúan como cajas/envolturas alrededor de estas primitivas, lo que hace posible usarlas como objetos.

Estrategia:

para convertir un Double a una Integer tendrías que seguir esta estrategia:

1. Convertir el Double objetar a un primitivo double. (= “desempaquetado”)
2. Convertir el primitivo double a un primitivo int. (= “fundición”)
3. Convertir el primitivo int volver a un Integer objeto. (= “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 desde un Double directo a un primitivo int. De esa manera, puede omitir el paso 2 por completo.

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

Trampas:

Sin embargo, hay muchas cosas que no están cubiertas en el código anterior. El código de arriba es no null-a salvo.

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 números 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 = indefinido (NaN)

Por lo tanto, según la aplicación, es posible que desee agregar algunos filtros para evitar excepciones desagradables.

Entonces, la siguiente deficiencia 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 solo está tirando algunos de los bytes. En aplicaciones financieras, seguramente querrá usar el redondeo a la mitad (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ías tener la tentación de usar el (des)boxeo automático en esto, pero yo no lo haría. Si ya está atascado ahora, los siguientes ejemplos tampoco serán tan obvios. Si no comprende el funcionamiento interno del (des)boxeo automático, 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í, es posible que desee leer algún artículo sobre la conversión en Java.

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

Preferir valor de:

Además, no caiga en la tentación de usar new Integer() constructor (como proponen otras respuestas). los valueOf() Los métodos son mejores porque utilizan el almacenamiento en caché. Es un buen hábito usar estos métodos, porque de vez en cuando te ahorrarán algo de memoria.

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

Sección de Reseñas y Valoraciones

Si aceptas, eres capaz de dejar un enunciado acerca de qué te ha impresionado de esta noticia.

---

---

Utiliza Nuestro Buscador