round - redondear a dos decimales java

¿Cómo redondeo un doble a dos lugares decimales en Java?

Question

Esto es lo que hice para redondear un doble a 2 lugares decimales:

amount = roundTwoDecimals(amount);

public double roundTwoDecimals(double d) {
    DecimalFormat twoDForm = new DecimalFormat("#.##");
    return Double.valueOf(twoDForm.format(d));
}

Esto funciona muy bien si la cantidad = 25.3569 o algo así, pero si la cantidad = 25.00 o la cantidad = 25.0, ¡entonces obtengo 25.0! Lo que quiero es tanto redondear como formatear con 2 decimales.

Answer 1

¿Estás trabajando con dinero? Crear una String y luego convertirla es bastante repetitivo.

Use BigDecimal . Esto ha sido discutido ampliamente. Deberías tener una clase Money y la cantidad debería ser un BigDecimal .

Incluso si no está trabajando con dinero, considere BigDecimal .

Answer 2

Al iniciar Java 1.8 puede hacer más con las expresiones lambda y comprueba null. Además, uno a continuación puede manejar Flotante o Número doble y variable de decimales (incluyendo 2 :-)).

public static Double round(Number src, int decimalPlaces) {

    return Optional.ofNullable(src)
            .map(Number::doubleValue)
            .map(BigDecimal::new)
            .map(dbl -> dbl.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP))
            .map(BigDecimal::doubleValue)
            .orElse(null);
}

Answer 3

Aquí hay una manera fácil que garantiza dar como resultado myFixedNumber redondeado a dos lugares decimales:

import java.text.DecimalFormat;

public class TwoDecimalPlaces {
    static double myFixedNumber = 98765.4321;
    public static void main(String[] args) {

        System.out.println(new DecimalFormat("0.00").format(myFixedNumber));
    }
}

El resultado es: 98765.43

Answer 4

Esto es lo más simple que podría hacer, pero hace el trabajo mucho más fácil que la mayoría de los ejemplos que he visto.

    double total = 1.4563;

    total = Math.round(total * 100);

    System.out.println(total / 100);

El resultado es 1.46.

Answer 5

No puede ''redondear un doble a [cualquier número de] lugares decimales'', porque los dobles no tienen lugares decimales. Puede convertir una secuencia doble a una cadena base-10 con N lugares decimales, porque la base-10 tiene lugares decimales, pero cuando la vuelve a convertir está de vuelta en doble-tierra, con lugares fraccionarios binarios .

Answer 6

Primero declara un objeto de la clase DecimalFormat . Tenga en cuenta que el argumento dentro de DecimalFormat es #.00 que significa exactamente 2 decimales de redondeo.

private static DecimalFormat df2 = new DecimalFormat("#.00");

Ahora, aplique el formato a su doble valor:

double input = 32.123456;
System.out.println("double : " + df2.format(input)); // Output: 32.12

Nota en caso de double input = 32.1;

Entonces la salida sería 32.10 y así sucesivamente.

Answer 7

Puede usar org.apache.commons.math.util.MathUtils desde apache common

double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);

Answer 8

Puedes probar este:

public static String getRoundedValue(Double value, String format) {
    DecimalFormat df;
    if(format == null)
        df = new DecimalFormat("#.00");
    else 
        df = new DecimalFormat(format);
    return df.format(value);
}

o

public static double roundDoubleValue(double value, int places) {
    if (places < 0) throw new IllegalArgumentException();

    long factor = (long) Math.pow(10, places);
    value = value * factor;
    long tmp = Math.round(value);
    return (double) tmp / factor;
}

Answer 9

Puedes usar Apache Commons Math:

Precision.round(double x, int scale)

fuente: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html#round(double,%20int)

Answer 10

Si desea el resultado con dos decimales, puede hacer

// assuming you want to round to Infinity.
double tip = (long) (amount * percent + 0.5) / 100.0; 

Este resultado no es preciso, pero Double.toString (doble) lo corregirá e imprimirá uno o dos lugares decimales. Sin embargo, tan pronto como realice otro cálculo, puede obtener un resultado que no será redondeado implícitamente. ;)

Answer 11

Solo use: (fácil como un pastel)

double number = 651.5176515121351;

number = Math.round(number * 100);
number = number/100;

La salida será 651.52

Answer 12

Su clase Money podría representarse como una subclase de Long o tener un miembro que represente el valor monetario como long nativo. Luego, al asignar valores a las instancias de dinero, siempre estará almacenando valores que en realidad son valores de dinero REAL. Simplemente emite su objeto Money (a través de su método Money overrden toString ()) con el formato adecuado. por ejemplo, $ 1.25 en la representación interna de un objeto de Money es 125. Usted representa el dinero como centavos, o peniques o lo que sea que la denominación mínima en la moneda con la que está sellando es ... luego formatee en salida. No, NUNCA puede almacenar un valor de dinero "ilegal", como por ejemplo $ 1.257.

Answer 13

Suponiendo que la cantidad puede ser tanto positiva como negativa, el redondeo a dos decimales puede usar la siguiente porción de fragmento de código.

amount = roundTwoDecimals(amount);

public double roundTwoDecimals(double d) {
    if (d < 0)
       d -= 0.005;
    else if (d > 0)
       d += 0.005;
    return (double)((long)(d * 100.0))/100);
}

Answer 14

Use un marcador de posición de dígito ( 0 ), ya que los ''ceros'' al final o '' # '' se muestran como ausentes:

DecimalFormat twoDForm = new DecimalFormat("#.00");

Answer 15

Utilizar esta

String.format ("% .2f", doubleValue) // cambia 2, de acuerdo con tu requerimiento.

Answer 16

cantidad doble = 25.00;

Formatter NumberFormat = nuevo DecimalFormat ("# 0.00");

System.out.println (formatter.format (amount));

Answer 17

donde num es el número doble

• El número entero 2 denota la cantidad de decimales que queremos imprimir.

• Aquí estamos tomando 2 espacios decimales

  System.out.printf ("%. 2f", num);

Answer 18

Math.round es una respuesta,

public class Util {
 public static Double formatDouble(Double valueToFormat) {
    long rounded = Math.round(valueToFormat*100);
    return rounded/100.0;
 }
}

Prueba en Spock, Groovy

void "test double format"(){
    given:
         Double performance = 0.6666666666666666
    when:
        Double formattedPerformance = Util.formatDouble(performance)
        println "######################## formatted ######################### => ${formattedPerformance}"
    then:
        0.67 == formattedPerformance

}

Answer 19

    int i = 180;
    int j = 1;
    double div=  ((double)(j*100)/i);
    DecimalFormat df = new DecimalFormat("#.00"); // simple way to format till any deciaml points
    System.out.println(div);
    System.out.println(df.format(div));

Answer 20

DecimalFormat df = new DecimalFormat("###.##");
double total = Double.valueOf(val);