Java: ¿cómo obtengo la parte después del punto decimal?

Tengo double variable d = 1.15.Java: ¿cómo obtengo la parte después del punto decimal?

Quiero el número después del punto decimal, es decir, "15".

¿Cuál es la mejor manera de lograr esto en Java?

He tratado de esta manera:

Double d = 1.15; 
String str = d.toString(); 
int len = str.substring(str.indexOf(".")).length() - 1; 
int i= (int) (d * (long)Math.pow(10,len) % (long)Math.pow(10,len));

pero yo no obtener la respuesta correcta, porque cuando convierto d.toString() la respuesta es 14.999999999999986.

Por favor ayuda. Gracias.

Fuente

2012-01-17 user1023675

http://stackoverflow.com/questions/5017072/how-to-get-the-decimal-part-of-a-float – John

Esta pregunta ha sido informativa para mí - He aprendido cuántas personas no hacen En realidad, ejecutas el código que publican, o realmente lees la pregunta. La pregunta es cómo obtener '15' de' 1.15'. Solo Arjun lo ha descifrado hasta ahora, porque vio este problema como lo que realmente es: una cuestión de análisis de cadenas. El hecho de que el afiche haya intentado usar matemáticas no significa que la respuesta deba seguir el mismo camino. – Paul

@Paul - Diría que el último ejemplo (negativo) del PO desmiente esa teoría. Si esto fuera simplemente un problema de análisis de cadenas, entonces el OP estaría contento con "999999999986" como la respuesta ... –

Al igual que en cualquier otro idioma: multiplique por 10 y compruebe la parte int del remanente al dividir por 10. De la misma manera que extraería los dígitos de un número entero.


short[] digits = new short[max_len]; 
double tmp = d - ((int) d); 
for (int i = 0; i < digits.length && tmp != 0; i++) 
{ 
    tmp *= 10; 
    digit[i] = (short) tmp; 
    tmp -= (int) tmp; 
}

Pero tenga en cuenta que para duplicar lo necesario para introducir un límite de precisión - el número máximo de dígitos para extraer (max_len del ejemplo de código anterior).

actualización leve (añadido redondeo en el borde de precisión):

double d = 1.15; 
     short[] digits = new short[10]; 
     double tmp = d - ((int) d) + 0.5 * 1e-10; 
     for (int i = 0; i < digits.length && tmp != 0; i++) 
     { 
      tmp *= 10; 
      digits[i] = (short) tmp; 
      tmp -= (int) tmp; 
     }

Fuente

2012-01-17 06:22:24

-1 Wow, no solo su código no funciona, esto es demasiado complejo para la pregunta.Ejecuté su código y la matriz contenía 1 y 4, para un valor de entrada de 1.15. – Paul

En realidad, el resultado es 1 4 9 9 9 9 9 9 9 9 ... Así es con los dobles: no se puede decir con precisión cuántos dígitos tiene después del punto debido a la inexactitud de sus aritméticos. Y si obtuviste ese doble de alguna expresión (no definiendo explícitamente su valor) asegúrate de que tenga imprecisión. Es por eso que le dije sobre el límite de precisión. Stephen C dio una buena explicación para ello más arriba. –

Ejecuté su código y obtuve una matriz de 2 que contenía un 1 y un 4. Establecí 'max_len' en 2 ya que quería una respuesta de 2 caracteres:' 15'. Él no está tratando de hacer matemáticas, solo quiere texto. – Paul

¿Ha intentado d = d%1.0? Eso debería devolver el resto de dividir d por 1, que debería ser solo la porción decimal.

También puede hacer esto para conseguir el valor como un int: d = (int)((d%1.0)*100)

Fuente

2012-01-17 06:22:39 aoi222

No creo que funcione así para los números de coma flotante. –

No estaba seguro de que al principio tampoco, pero después de leer esto estoy bastante seguro de que sí, a menos que lo haya leído mal. http://stackoverflow.com/questions/2947044/how-do-i-use-modulus-for-float-double – aoi222

Wow, eso es realmente una característica interesante. Bien, ahora sé de esto. Gracias. –

probar esto,

String numberD = String.valueOf(d); 
     numberD = numberD.subString (numberD.indexOf ("."));

Ahora esta variable numberd tendrá un valor de 24

Fuente

2012-01-17 06:23:44 Android

+1, es simple y la respuesta no tiene que ser matemática. Tratarlo como un problema de "Cadena" elimina los problemas con precisión. Buen trabajo. – Paul

Esto es incorrecto. Obtendrás decimal y parte del resultado. No estoy seguro de por qué fue votado por los lectores sin siquiera intentarlo. La respuesta de Peter es correcta. Necesitas otra .substring (1) al final. – rajneesh2k10

no, no devolverá el valor de '.24'. Modifique 'numberD.indexOf ('.') + 1' para obtener' 24'. –

Trate Math.floor ();

double d = 4.24; 
System.out.println(d - Math.floor(d));

Para evitar errores de redondeo se pueden convertir a BigDecimal

double d = 4.24; 
    BigDecimal bd = new BigDecimal(d - Math.floor(d)); 
    bd = bd.setScale(4,RoundingMode.HALF_DOWN); 
    System.out.println(bd.toString());

imprime 0,2400

Tenga en cuenta que el 4 en setScale es el número de dígitos después del separador decimal ('') Para obtener el resto como un valor entero, puede modificar esto a

BigDecimal bd = new BigDecimal((d - Math.floor(d)) * 100); 
bd = bd.setScale(4,RoundingMode.HALF_DOWN); 
System.out.println(bd.intValue());

Prints 24

Fuente

2012-01-17 06:27:07 stacker

Ejecuté su código y obtuve '0.2400000000000002' - No creo que él lo encuentre útil. ¿Todo ese representante y no puedes probar tu código? : D – Paul

@Paul, es un error de redondeo, debería haber oído hablar de ellos. –

@Paul Thanks lo arregló, es una representación IEEE 754 que solo necesita redondear el valor. – stacker

El número después del punto decimal no es un concepto bien definido. Por ejemplo, para "4.24", podría ser "0.24", "0.239999999999" (o similar), "24" o "239999999999".

Debe ser claro si está hablando de un número o una cadena de dígitos decimales ... y si el valor de entrada es una representación de un número de punto flotante binario (en cuyo caso "4.24" es muy probable que aproximación) un número de coma flotante decimal.

Dependiendo de su interpretación, la respuesta correcta será diferente.

pero no lo hice obtener la respuesta correcta porque cuando me convertí d.toString() la respuesta es 14,999999999999986.

está ejecutando con el problema de que double y float son formatos de punto flotante en base 2, y en la mayoría de los casos no pueden representar números decimales de coma flotante con precisión. No hay ninguna solución para esto ... aparte de usar algo como BigDecimal para representar sus números. (Y aun así, es posible perder algo de precisión cada vez que realice una operación de división o módulo).

Fuente

2012-01-17 06:31:10

Si desea los lugares decimales y desea redondear el resultado.

double d = 4.24; 
System.out.printf("%0.2f%n", d - (long) d);

impresiones

0.24

Si desea un valor redondeado, que tienen que determinar qué precisión que desee.

double d = 4.24; 
double fract = d - (long) d; 
fract = (long) (fract * 1e9 + 0.5)/1e9; // round to the 9 decimal places.

Fuente

2012-01-17 06:45:56

En lugar de d.toString(), intente esto:

String str = String.format("%.2f", d);

Fuente

2012-01-17 06:58:34

Si su doble es:

d = 1.25;

Y si hace esto:

String number = String.valueOf(d); 

number = number.substring(number.indexOf(".")).substring(1);

continuación number habrá 25.

No sé si esta es la mejor manera de hacerlo, pero funciona.

Fuente

2013-08-18 11:08:00 Peter

Java: ¿cómo obtengo la parte después del punto decimal?

Respuesta

Cuestiones relacionadas