Formatea un doble para omitir el ".0" innecesario y nunca redondear

Question

Sé cómo formatear un doble para mantener solo los decimales disponibles (DP), hasta un cierto número de DP. Este ejemplo mantiene hasta 4 DP.

double d = 1.0; 
    DecimalFormat df = new DecimalFormat("#.####"); 
    System.out.print(df.format(d)); // returns "1" 

    double d = 1.23; 
    DecimalFormat df = new DecimalFormat("#.####"); 
    System.out.print(df.format(d)); // returns "1.23" 

    double d = 1.2345678; 
    DecimalFormat df = new DecimalFormat("#.####"); 
    System.out.print(df.format(d)); // returns "1.2346", rounding off: bad! 

Ahora quiero números enteros p. Ej. 1.0 para devolver "1" sin el innecesario .0, y el carácter de formato # proporciona esa funcionalidad. ¿Pero cómo me aseguro de que el número nunca se redondea? ¿Hay alguna otra manera que no sea una cadena arbitrariamente larga de # como "#.###########################################"?

O debo utilizar la conversión por defecto de doble cadena a, y truncar el ".0" si aparece al final:

String s = "" + d; 
    if(s.substring(s.length()-2).equals(".0")) { 
     s=s.substring(0, s.length()-2); 
    } 

Ambas formas parece terriblemente torpe.

Answer 1

utilizo el siguiente

double d = 
String s = (long) d == d ? "" + (long) d : "" + d; 

si necesita doble en vez de dos. (Personalmente me gustaría evitar el uso de la envoltura si es posible)

Double d = 
String s = d.longValue() == d ? "" + d.longValue() : "" + d; 

Answer 2

Usted podría utilizar Double.doubleToLongBits() y extraer el exponente y la mantisa. Desde api doc:

Bit 63 (el bit que es seleccionado por la máscara 0x8000000000000000L) representa el signo del número en coma flotante. Los bits 62-52 (los bits que se seleccionan mediante la máscara 0x7ff0000000000000L) representan el exponente . Los bits 51-0 (los bits seleccionados por la máscara 0x000fffffffffffffL) representan el significado (a veces llamado mantisa) del número de coma flotante.

El exponente se puede usar para determinar el número de dígitos significativos, pero siempre tendrá que redondear en algún punto ya que algunos valores binarios de doulbe serán infinitos en decimales.

Para una representación binaria puede simplemente utilizar la mantisa y poner el punto decimal en la posición correcta (relleno con ceros si es necesario.

Answer 3

Por defecto, el modo de redondeo está a la DecimalFormat. Puede establecer diferentes formatos de redondeo como por su requiremnet usando setRoundingMode() método Código

de ejemplo para establecer el modo de redondeo

double d = 1.2345678; 
     DecimalFormat df = new DecimalFormat("#.####"); 
     df.setRoundingMode(RoundingMode.DOWN); 
     System.out.print(df.format(d));//result 1.2345 because of rounding down