En Supposant que value est un double, vous pouvez faire:

(double)Math.round(value * 100000d) / 100000d

C'est pour une précision de 5 chiffres. Le nombre de zéros indique le nombre de décimales.

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

Vous donnera un BigDecimal. Pour en extraire la chaîne, appelez simplement cette méthode BigDecimal's toString, ou la méthode toPlainString pour Java 5+ pour une chaîne de format simple.

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));
    }

Vous pouvez également utiliser le

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

Pour vous assurer que vous avez les 0 de fin.

Comme d'autres l'ont noté, la bonne réponse est d'utiliser DecimalFormat ou BigDecimal. La virgule flottante n'a pas de décimales, vous ne pouvez donc pas arrondir/tronquer à un nombre spécifique d'entre elles en premier lieu. Vous devez travailler dans une base décimale, et c'est ce que font ces deux classes.

Je poste le code suivant comme contre-exemple à toutes les réponses de ce thread et en effet partout dans StackOverflow (et ailleurs) qui recommandent la multiplication suivie de troncature suivie de division. Il incombe aux défenseurs de cette technique d'expliquer pourquoi le code suivant produit 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");
    }
}

Sortie de ce programme:

10001 trials 9251 errors

EDIT: Pour répondre à certains commentaires ci-dessous, j'ai refait la partie module de la boucle de test en utilisant BigDecimal et new MathContext(16) pour l'opération module 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

Supposons que vous ayez

double d = 9232.129394d;

Vous pouvez utiliser BigDecimal

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();

Ou sans BigDécimal

d = Math.round(d*100)/100.0d;

, Avec les deux solutions d == 9232.13

Vous pouvez utiliser la classe DecimalFormat.

double d = 3.76628729;

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

How-to Java de Real publie cette solution, qui est également compatible pour les versions antérieures à Java 1.6.

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();

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

@ Milhous: le format décimal pour arrondir est excellent:

Vous pouvez également utiliser le

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

Pour vous assurer que vous avez les 0 de fin.

J'ajouterais que cette méthode est très bonne pour fournir un réel numérique, mécanisme d'arrondi - non seulement visuellement, mais aussi lors du traitement.

Hypothétique: vous devez implémenter un mécanisme d'arrondi dans une interface graphique programme. Pour modifier la précision / précision d'une sortie de résultat simplement modifier le format du caret (c'est à dire à l'intérieur des parenthèses). De sorte que:

DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);

Retournerait en sortie: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);

Retournerait en sortie: 0.91239

DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);

Retournerait en sortie: 0.9124

[EDIT: aussi si le format caret est comme ça ("#0.############") et vous entrez une décimale, par exemple 3.1415926, pour l'argument, DecimalFormat ne produit pas de déchets (par exemple, les zéros de fin) et retournera: 3.1415926 .. si vous êtes de cette façon enclin. Certes, c'est un peu verbeux pour le goût de certains dev - mais bon, il a une faible empreinte mémoire pendant le traitement et est très facile à mettre en œuvre.]

Donc essentiellement, la beauté de DecimalFormat est qu'il gère simultanément la chaîne apparence - ainsi que le niveau d'arrondi jeu de précision. Ergo: vous obtenez deux avantages pour le prix d'une implémentation de code. ;)

Vous pouvez utiliser la méthode utilitaire suivante -

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

Voici un résumé de ce que vous pouvez utiliser si vous voulez le résultat sous forme de chaîne:

1. DecimalFormat#setRoundingMode():

   DecimalFormat df = new DecimalFormat("#.#####");
   df.setRoundingMode(RoundingMode.HALF_UP);
   String str1 = df.format(0.912385)); // 0.91239
   

2. BigDecimal#setScale()

   String str2 = new BigDecimal(0.912385)
       .setScale(5, BigDecimal.ROUND_HALF_UP)
       .toString();
   

Voici une suggestion des bibliothèques que vous pouvez utiliser si vous voulez double en conséquence. Je ne le recommanderais pas pour la conversion de chaîne, cependant, car double peut ne pas être en mesure de représenter exactement ce que vous voulez (voir par exemple ici):

1. Précision de Apache Commons Math

   double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
   

2. Fonctions de Colt

   double rounded = Functions.round(0.00001).apply(0.912385)
   

3. Utils de Weka

   double rounded = Utils.roundDouble(0.912385, 5)
   

Une solution succincte:

   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 Merci àjpdymond d'avoir offert cela.

Vous pouvez utiliser BigDecimal

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);

Se référer à: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/

Essayez ceci: org.Apache.commun.math3.util.Précision.rond (double x, échelle int)

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

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

L'implémentation interne 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;
        }
    }
}

Puisque je n'ai pas trouvé de réponse complète sur ce thème, j'ai mis en place une classe qui devrait gérer cela correctement, avec le support de:

• Formatage : Formater facilement un double en chaîne avec un certain nombre de décimales
• Analyse : Analyse la valeur formatée à double
• Locale : Formater et analyser en utilisant les paramètres régionaux par défaut
• Notation exponentielle : Commencer à utiliser la notation exponentielle après un certain seuil

L'Utilisation est assez simple:

(Pour les besoins de cet exemple, j'utilise une locale personnalisée)

public static final int DECIMAL_PLACES = 2;

NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);

String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"

double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345

Ici, c'est la classe:

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;

public class NumberFormatter {

    private static final String SYMBOL_INFINITE           = "\u221e";
    private static final char   SYMBOL_MINUS              = '-';
    private static final char   SYMBOL_ZERO               = '0';
    private static final int    DECIMAL_LEADING_GROUPS    = 10;
    private static final int    EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
    private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation

    private DecimalFormat decimalFormat;
    private DecimalFormat decimalFormatLong;
    private DecimalFormat exponentialFormat;

    private char groupSeparator;

    public NumberFormatter(int decimalPlaces) {
        configureDecimalPlaces(decimalPlaces);
    }

    public void configureDecimalPlaces(int decimalPlaces) {
        if (decimalPlaces <= 0) {
            throw new IllegalArgumentException("Invalid decimal places");
        }

        DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
        separators.setMinusSign(SYMBOL_MINUS);
        separators.setZeroDigit(SYMBOL_ZERO);

        groupSeparator = separators.getGroupingSeparator();

        StringBuilder decimal = new StringBuilder();
        StringBuilder exponential = new StringBuilder("0.");

        for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
            decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
        }

        for (int i = 0; i < decimalPlaces; i++) {
            decimal.append("#");
            exponential.append("0");
        }

        exponential.append("E0");

        decimalFormat = new DecimalFormat(decimal.toString(), separators);
        decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
        exponentialFormat = new DecimalFormat(exponential.toString(), separators);

        decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
        decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
        exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
    }

    public String format(double value) {
        String result;
        if (Double.isNaN(value)) {
            result = "";
        } else if (Double.isInfinite(value)) {
            result = String.valueOf(SYMBOL_INFINITE);
        } else {
            double absValue = Math.abs(value);
            if (absValue >= 1) {
                if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
                    value = Math.floor(value);
                    result = exponentialFormat.format(value);
                } else {
                    result = decimalFormat.format(value);
                }
            } else if (absValue < 1 && absValue > 0) {
                if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
                    result = decimalFormat.format(value);
                    if (result.equalsIgnoreCase("0")) {
                        result = decimalFormatLong.format(value);
                    }
                } else {
                    result = exponentialFormat.format(value);
                }
            } else {
                result = "0";
            }
        }
        return result;
    }

    public String formatWithoutGroupSeparators(double value) {
        return removeGroupSeparators(format(value));
    }

    public double parse(String value, double defValue) {
        try {
            return decimalFormat.parse(value).doubleValue();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return defValue;
    }

    private String removeGroupSeparators(String number) {
        return number.replace(String.valueOf(groupSeparator), "");
    }

}

Juste au cas où quelqu'un aurait encore besoin d'aide. Cette solution fonctionne parfaitement pour moi.

private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals,  BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();

}

Renvoie un String avec la sortie souhaitée.

Si vous voulez vraiment des nombres décimaux pour le calcul (et pas seulement pour la sortie), n'utilisez pas un format à virgule flottante binaire comme double.

Use BigDecimal or any other decimal-based format.

J'utilise BigDecimal pour les calculs, mais gardez à l'esprit qu'il dépend de la taille de des chiffres avec lesquels vous avez affaire. Dans la plupart de mes implémentations, je trouve l'analyse de double ou entier à long est suffisant pour les calculs de très grands nombres.

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

Si vous utilisez DecimalFormat pour convertir double à String, c'est très simple:

DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);

double num = 1.234567;
return formatter.format(num);

Il existe plusieurs valeurs d'énumération RoundingMode à sélectionner, en fonction du comportement dont vous avez besoin.

L'extrait de code ci-dessous montre comment afficher n chiffres. L'astuce consiste à définir la variable pp à 1 suivie de n zéros. Dans l'exemple ci-dessous, la valeur pp variable 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 en voulant juste une réponse simple sur la façon d'arrondir un nombre. Ceci est une réponse supplémentaire pour fournir cela.

Comment arrondir un nombre en Java

Le cas le plus courant consiste à utiliser Math.round().

Math.round(3.7) // 4

Les Nombres sont arrondis au nombre entier le plus proche. Une valeur .5 est arrondie à la hausse. Si vous avez besoin d'un comportement d'arrondi différent de celui - ci, vous pouvez utiliser l'une des autres fonctions Math. Voir le comparatif ci-dessous.

Ronde

Comme indiqué ci-dessus, cela arrondit au nombre entier le plus proche. .5 décimales arrondies. Cette méthode renvoie 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 valeur décimale est arrondie à l'entier suivant. Il va au ceil ing. Cette méthode renvoie 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

Plancher

Toute valeur décimale est arrondie à l'entier suivant. Cette méthode renvoie 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 à round en ce sens les valeurs décimales arrondir à l'entier le plus proche. Cependant, contrairement à round, .5 les valeurs sont arrondies à l'entier pair. Cette méthode renvoie 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 ***

Je suis d'accord avec la réponse choisie d'utiliser DecimalFormat --- ou sinon BigDecimal.

Veuillez lire d'abord Update ci-dessous!

Cependant, si vous faites voulez arrondir la valeur double et obtenir un résultat de valeur double, vous pouvez utiliser org.apache.commons.math3.util.Precision.round(..) comme mentionné ci-dessus. L'implémentation utilise BigDecimal, est lente et crée des ordures.

Une méthode similaire mais rapide et sans déchets est fournie par l'utilitaire DoubleRounder de la bibliothèque decimal4j:

 double a = DoubleRounder.round(2.0/3.0, 3);
 double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
 double c = DoubleRounder.round(1000.0d, 17);
 double d = DoubleRounder.round(90080070060.1d, 9);
 System.out.println(a);
 System.out.println(b);
 System.out.println(c);
 System.out.println(d);

Sera sortie

 0.667
 0.666
 1000.0
 9.00800700601E10

Voir https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

Avertissement: je suis impliqué dans le decimal4j projet.

Mise à Jour: Comme l'a souligné @iaforek, DoubleRounder renvoie parfois des résultats contre-intuitifs. La raison en est qu'il effectue un arrondi mathématiquement correct. Par exemple, {[8] } sera arrondi à 256,02 car la valeur double représentée par 256,025 d est un peu plus petite que la valeur valeur rationnelle 256.025 et sera donc arrondie vers le bas.

Notes:

• Ce comportement est très similaire à celui du constructeur BigDecimal(double) (mais pas à valueOf(double) qui utilise le constructeur string).
• Le problème peut d'abord être contourné avec une double étape d'arrondi à une précision supérieure, mais c'est compliqué et je n'entre pas dans les détails ici

Pour ces raisons et tout ce qui est mentionné ci-dessus dans ce post, je ne peux pas recommander pour utiliser DoubleRounder.

DecimalFormat est le meilleur moyen de sortir, mais je ne le préfère pas. Je le fais toujours tout le temps, car il renvoie la double valeur. Je peux donc l'utiliser plus qu'une simple sortie.

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

OU

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

Si vous avez besoin de grandes décimales, vous pouvez utiliser BigDecimal à la place. Quoi qu'il en soit .0 est important. Sans cela, l'arrondi de 0. 33333d5 renvoie 0.33333 et seuls 9 chiffres sont autorisés. La deuxième fonction sans .0 a des problèmes avec 0.30000 retourne 0.300000000000000004.

Pour y parvenir, nous pouvons utiliser ce formateur:

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

Ou:

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

Utilisez 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);
    }

Définition de ces valeurs:

91.32
5.22
11.5
1.2
2.6

En utilisant la méthode, nous pouvons obtenir ces résultats:

91.32
5.22
11.50
1.20
2.60

Démo en ligne.

Gardez à l'esprit cette chaîne.format () et DecimalFormat produisent une chaîne en utilisant les paramètres régionaux par défaut. Ils peuvent donc écrire un nombre formaté avec un point ou une virgule comme séparateur entre les parties entières et décimales. Pour vous assurer que la chaîne arrondie est dans le format souhaité, utilisez java.texte.NumberFormat comme tel:

  Locale locale = Locale.ENGLISH;
  NumberFormat nf = NumberFormat.getNumberInstance(locale);
  // for trailing zeros:
  nf.setMinimumFractionDigits(2);
  // round to 2 digits:
  nf.setMaximumFractionDigits(2);

  System.out.println(nf.format(.99));
  System.out.println(nf.format(123.567));
  System.out.println(nf.format(123.0));

Imprimera en langue anglaise (quelle que soit votre langue): 0.99 123.57 123.00

L'exemple est tiré de Farenda - comment convertir double en chaîne correctement.

Où dp = décimale que vous voulez, et la valeur est un double.

    double p = Math.pow(10d, dp);

    double result = Math.round(value * p)/p;

Si vous considérez 5 ou n nombre de décimales. Peut-être que cette réponse résout votre problème.

    double a = 123.00449;
    double roundOff1 = Math.round(a*10000)/10000.00;
    double roundOff2 = Math.round(roundOff1*1000)/1000.00;
    double roundOff = Math.round(roundOff2*100)/100.00;

    System.out.println("result:"+roundOff);

La Sortie sera: 123.01
cela peut être résolu avec une boucle et une fonction récursive.

Si vous utilisez une technologie qui a un JDK minimal. Voici un moyen sans aucune bibliothèque Java:

double scale = 100000;    
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;

En général, l'arrondi se fait par 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