Comment arrondir un nombre à n chiffres après la virgule dans Java

Utilisation setRoundingMode, définir la RoundingMode explicitement pour traiter votre problème avec le demi-même round, puis utilisez le modèle de format pour votre sortie requise.

Exemple:

DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
    Double d = n.doubleValue();
    System.out.println(df.format(d));
}

donne la sortie:

12
123.1235
0.23
0.1
2341234.2125

MODIFIER: l'original de La réponse ne traite pas l'exactitude des valeurs doubles. C'est très bien si vous n'avez pas beaucoup de soins si elle arrondit vers le haut ou vers le bas. Mais si vous voulez précise l'arrondissement, alors vous devez prendre la précision attendue des valeurs en compte. Les valeurs à virgule flottante ont une représentation binaire en interne. Cela signifie qu'une valeur comme 2.77395 n'a pas en fait que la valeur exacte en interne. Il peut être légèrement supérieur ou légèrement plus petit. Si la valeur interne est légèrement plus petit, il ne sera alors pas rond, jusqu'à 2.7740. Pour remédier à cette situation, vous devez être conscient de la précision des valeurs que vous travaillez avec, et d'ajouter ou de soustraire cette valeur avant de l'arrondissement. Par exemple, quand vous savez que vos valeurs sont précises jusqu'à 6 chiffres, puis tour à mi-chemin valeurs, ajouter de l'exactitude de la valeur:

Double d = n.doubleValue() + 1e-6;

D'arrondir à la baisse, soustrait la précision.

new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);

vous obtiendrez un BigDecimal. Pour obtenir la chaîne de caractères en dehors de ça, il suffit d'appeler que BigDecimal's toString méthode, ou la toPlainString méthode pour Java 5+ pour une simple chaîne de format.

Exemple de programme:

package trials;
import java.math.BigDecimal;

public class Trials {

    public static void main(String[] args) {
        int yourScale = 10;
        System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
    }

Comme certains l'ont noté, la réponse correcte est d'utiliser soit DecimalFormat ou BigDecimal. Virgule flottante n'est pas ont décimales de sorte que vous ne peut pas rond/truncate à un certain nombre d'entre eux dans la première place. Vous avez à travailler dans un décimal radix, et c'est ce que ces deux classes.

Que j'ai écris le code suivant comme un contre-exemple pour toutes les réponses dans ce fil et, de fait, tous sur StackOverflow (et d'ailleurs) qui recommandent de multiplication suivie par la troncature suivi par la division. Il revient sur les défenseurs de cette technique, pour expliquer pourquoi le code suivant donne la mauvaise sortie dans plus de 92% des cas.

public class RoundingCounterExample
{

    static float roundOff(float x, int position)
    {
        float a = x;
        double temp = Math.pow(10.0, position);
        a *= temp;
        a = Math.round(a);
        return (a / (float)temp);
    }

    public static void main(String[] args)
    {
        float a = roundOff(0.0009434f,3);
        System.out.println("a="+a+" (a % .001)="+(a % 0.001));
        int count = 0, errors = 0;
        for (double x = 0.0; x < 1; x += 0.0001)
        {
            count++;
            double d = x;
            int scale = 2;
            double factor = Math.pow(10, scale);
            d = Math.round(d * factor) / factor;
            if ((d % 0.01) != 0.0)
            {
                System.out.println(d + " " + (d % 0.01));
                errors++;
            }
        }
        System.out.println(count + " trials " + errors + " errors");
    }
}

De sortie de ce programme:

10001 trials 9251 errors

EDIT: pour répondre À certains commentaires ci-dessous j'ai refait le module de la partie de la boucle de test à l'aide de BigDecimal et new MathContext(16) pour le module de l'opération comme suit:

public static void main(String[] args)
{
    int count = 0, errors = 0;
    int scale = 2;
    double factor = Math.pow(10, scale);
    MathContext mc = new MathContext(16, RoundingMode.DOWN);
    for (double x = 0.0; x < 1; x += 0.0001)
    {
        count++;
        double d = x;
        d = Math.round(d * factor) / factor;
        BigDecimal bd = new BigDecimal(d, mc);
        bd = bd.remainder(new BigDecimal("0.01"), mc);
        if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
        {
            System.out.println(d + " " + bd);
            errors++;
        }
    }
    System.out.println(count + " trials " + errors + " errors");
}

Résultat:

10001 trials 4401 errors

Vous pouvez utiliser le DecimalFormat classe.

double d = 3.76628729;

DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal =  Double.valueOf(newFormat.format(d));

double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;

Vous pouvez utiliser l'utilitaire suivant la méthode

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}

Un succincte solution:

   public static double round(double value, int precision) {
      int scale = (int) Math.pow(10, precision);
      return (double) Math.round(value * scale) / scale;
  }

Voir aussi, https://stackoverflow.com/a/22186845/212950
Grâce à jpdymond offre ce.

Essayez ceci: org.apache.commons.math3.util.La précision.round(double x, int échelle)

Voir: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

Apache Commons Bibliothèque de Mathématiques page d'accueil est: http://commons.apache.org/proper/commons-math/index.html

Internes de mise en œuvre de cette méthode est:

public static double round(double x, int scale) {
    return round(x, scale, BigDecimal.ROUND_HALF_UP);
}

public static double round(double x, int scale, int roundingMethod) {
    try {
        return (new BigDecimal
               (Double.toString(x))
               .setScale(scale, roundingMethod))
               .doubleValue();
    } catch (NumberFormatException ex) {
        if (Double.isInfinite(x)) {
            return x;
        } else {
            return Double.NaN;
        }
    }
}

Si vous voulez vraiment les nombres décimaux pour le calcul (et non seulement de la production), ne pas utiliser une base binaire format à virgule flottante double.

Use BigDecimal or any other decimal-based format.

Je ne l'utilisation de BigDecimal pour les calculs, mais gardez à l'esprit qu'il est dépendant de la taille de
les numéros que vous avez affaire. Dans la plupart de mes réalisations, je trouve l'analyse de double ou
entier Long est suffisant pour un très grand nombre de calculs.

En fait, j'ai
utilisé récemment analysé-à-temps pour obtenir des représentations précises (par opposition à l'hex résultats)
dans une interface graphique, pour des nombres aussi grands que ################################# les personnages (comme un
exemple).

Pour parvenir à cela, nous pouvons utiliser ce formateur:

 DecimalFormat df = new DecimalFormat("#.00");
String resultado = df.format(valor)

ou:

DecimalFormat df = new DecimalFormat("0.00"); :

Utiliser cette méthode pour obtenir toujours à deux décimales:

   private static String getTwoDecimals(double value){
DecimalFormat df = new DecimalFormat("0.00"); 
return df.format(value);
}

La définition de ces valeurs:

91.32
5.22
11.5
1.2
2.6

À l'aide de la méthode on peut obtenir ces résultats:

91.32
5.22
11.50
1.20
2.60

démo en ligne.

L'extrait de code ci-dessous montre comment afficher les n chiffres. Le truc, c'est de définir la variable pp pour 1 suivi de n zéros. Dans l'exemple ci-dessous, la variable valeur pp a 5 zéros, donc 5 chiffres seront affichés.

double pp = 10000;
double myVal = 22.268699999999967;
String needVal = "22.2687";
double i = (5.0/pp);
String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();

Je suis venu ici simplement de vouloir une réponse simple sur comment arrondir un nombre. C'est un complément de réponse à fournir.

Comment arrondir un nombre en Java

Le cas le plus courant est d'utiliser Math.round().

Math.round(3.7) //4

Les nombres sont arrondis au nombre entier le plus proche. Un .5 valeur est arrondie. Si vous avez besoin de différentes arrondissement de comportement que cela, vous pouvez utiliser l'une de l'autre Mathématiques fonctions. Voir le comparatif ci-dessous.

ronde

Comme indiqué ci-dessus, ce arrondit à l'entier le plus proche. .5 décimales round up. Cette méthode retourne un int.

Math.round(3.0); //3
Math.round(3.1); //3
Math.round(3.5); //4
Math.round(3.9); //4
Math.round(-3.0); //-3
Math.round(-3.1); //-3
Math.round(-3.5); //-3 *** careful here ***
Math.round(-3.9); //-4

ceil

Toute la valeur décimale est arrondie au nombre entier le plus proche. Il va à la ceiling. Cette méthode retourne un double.

Math.ceil(3.0); //3.0
Math.ceil(3.1); //4.0
Math.ceil(3.5); //4.0
Math.ceil(3.9); //4.0
Math.ceil(-3.0); //-3.0
Math.ceil(-3.1); //-3.0
Math.ceil(-3.5); //-3.0
Math.ceil(-3.9); //-3.0

étage

Toute valeur décimale est arrondie au nombre entier le plus proche. Cette méthode retourne un double.

Math.floor(3.0); //3.0
Math.floor(3.1); //3.0
Math.floor(3.5); //3.0
Math.floor(3.9); //3.0
Math.floor(-3.0); //-3.0
Math.floor(-3.1); //-4.0
Math.floor(-3.5); //-4.0
Math.floor(-3.9); //-4.0

rint

Ceci est similaire à la ronde que les valeurs décimales arrondir à l'entier le plus proche. Cependant, contrairement à round, .5 des valeurs rondes de la même entier. Cette méthode retourne un double.

Math.rint(3.0); //3.0
Math.rint(3.1); //3.0
Math.rint(3.5); //4.0 ***
Math.rint(3.9); //4.0
Math.rint(4.5); //4.0 ***
Math.rint(5.5); //6.0 ***
Math.rint(-3.0); //-3.0
Math.rint(-3.1); //-3.0
Math.rint(-3.5); //-4.0 ***
Math.rint(-3.9); //-4.0
Math.rint(-4.5); //-4.0 ***
Math.rint(-5.5); //-6.0 ***

DecimalFormat est la meilleure des façons à la sortie, mais je ne préfère pas elle. J'ai toujours le faire tout le temps, parce qu'elle renvoie la valeur de type double. Donc je peux l'utiliser plus que juste sortie.

Math.round(selfEvaluate*100000d.0)/100000d.0;

OU

Math.round(selfEvaluate*100000d.0)*0.00000d1;

Si vous avez besoin d'un grand nombre de décimales de la valeur, vous pouvez utiliser BigDecimal à la place. De toute façon .0 est important. Sans elle, l'arrondissement de 0.33333d5 retour 0.33333 et seulement 9 chiffres permet. La deuxième fonction sans .0 a des problèmes avec 0.30000 retour 0.30000000000000004.

Où dp = nombre de décimales que vous souhaitez,
et valeur est un double.

    double p = Math.pow(10d, dp);
double result = Math.round(value * p)/p;

Donc, après la lecture de la plupart des réponses, j'ai réalisé que la plupart d'entre eux ne sera pas précis, en fait, à l'aide de BigDecimal semble être le meilleur choix, mais si vous ne comprenez pas comment le RoundingMode travaux, vous pouvez inévitable de perdre de la précision. J'ai compris cela lorsque l'on travaille avec de gros chiffres dans un projet et pense qu'il peut aider d'autres personnes ayant de la difficulté à l'arrondissement des chiffres. Par exemple.

BigDecimal bd = new BigDecimal("1363.2749");
bd = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println(bd.doubleValue());

Vous pouvez vous attendre à obtenir 1363.28 de sortie, mais vous allez vous retrouver avec 1363.27, ce qui n'est pas prévu, si vous ne savez pas ce que le RoundingMode est en train de faire. Donc à la recherche dans le Oracle Docs, vous trouverez la description de RoundingMode.HALF_UP.

Arrondissement mode d'arrondi vers "plus proche voisin" à moins que les deux
les voisins sont équidistants, auquel cas round up.

Donc, sachant cela, nous avons réalisé que nous ne seront pas obtenir un arrondi exact, si l'on ne veut arrondi vers voisin le plus proche. Donc, pour accomplir adéquat, à la ronde, nous aurions besoin de boucle de la n-1 décimal vers la décimales souhaité chiffres. Par exemple.

private double round(double value, int places) {
if (places < 0) throw new IllegalArgumentException();
//Cast the number to a String and then separate the decimals.
String stringValue = Double.toString(value);
String decimals = stringValue.split("\\.")[1];
//Round all the way to the desired number.
BigDecimal bd = new BigDecimal(stringValue);
for (int i = decimals.length()-1; i >= places; i--) {
bd = bd.setScale(i, RoundingMode.HALF_UP);
}
return bd.doubleValue();
}

Ce sera à la fin de nous donner les résultats attendus, ce qui serait 1363.28.

En général, l'arrondi est fait par la mise à l'échelle: round(num /p) * p

/**
* MidpointRounding away from zero ('arithmetic' rounding)
* Uses a half-epsilon for correction. (This offsets IEEE-754
* half-to-even rounding that was applied at the edge cases).
*/
double RoundCorrect(double num, int precision) {
double c = 0.5 * EPSILON * num;
// double p = Math.pow(10, precision); //slow
double p = 1; while (precision--> 0) p *= 10;
if (num < 0)
p *= -1;
return Math.round((num + c) * p) / p;
}
//testing edge cases
RoundCorrect(1.005, 2);   //1.01 correct
RoundCorrect(2.175, 2);   //2.18 correct
RoundCorrect(5.015, 2);   //5.02 correct
RoundCorrect(-1.005, 2);  //-1.01 correct
RoundCorrect(-2.175, 2);  //-2.18 correct
RoundCorrect(-5.015, 2);  //-5.02 correct