Double de la valeur à arrondir en Java

J'ai une double valeur = 1.068879335 je veux le tour, avec seulement deux valeurs décimales comme 1.07.

J'ai essayé comme ceci

DecimalFormat df=new DecimalFormat("0.00");
String formate = df.format(value);
double finalValue = Double.parseDouble(formate) ;

ce qui me donne cette exception suivante

java.lang.NumberFormatException: For input string: "1,07"
     at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)
     at java.lang.Double.parseDouble(Double.java:510)

peut-on me dire quel est le problème avec mon code.

finalement j'ai besoin de la finalValue = 1.07;

si vous autour de cette place, 1.085879335, 2 chiffres de précision, il sera 1.08 1.09 et s'arrondir. comment vous voulez obtenir 1.07 de 1.085879335?

InformationsquelleAutor jimmy | 2011-01-25

78

Notez la virgule dans votre chaîne de caractères: "1,07". DecimalFormat utilise les paramètres régionaux spécifiques séparateur de chaîne, tandis que Double.parseDouble() ne le fait pas. Comme vous vivez dans un pays où le séparateur décimal est le ",", vous ne pouvez pas analyser votre numéro de retour.

Cependant, vous pouvez utiliser le même DecimalFormat analyser dos:
```
DecimalFormat df=new DecimalFormat("0.00");
String formate = df.format(value); 
double finalValue = (Double)df.parse(formate) ;
```
Mais vous devriez vraiment faire ceci à la place:
```
double finalValue = Math.round( value * 100.0 ) / 100.0;
```
Remarque: Comme cela a été souligné, vous ne devez utiliser de virgule flottante si vous n'avez pas besoin d'un contrôle précis sur la précision. (Calculs financiers étant le principal exemple lorsque pas de l'utiliser.)
- +1 pour le fait d'identifier le problème. Vous pouvez aussi indiquer explicitement DecimalFormat d'utiliser le C locale.
- Comme je l'ai indiqué dans ma réponse, cet algorithme ne fonctionne généralement pas. Et tant que Java bâtons avec virgule flottante IEEE un tel algorithme n'existe pas.
- Compte tenu du contexte de la question, ma réponse est correcte. Fair-play pour vous faire réfléchir un peu plus loin, mais dois-je savoir downvote votre réponse parce que vous a complètement échoué à identifier pourquoi le code échec en premier lieu? Bien sûr, je ne devrais pas.
- Désolé, je ne voulais pas offenser. Je voulais simplement faire remarquer que même le code corrigé n'a pas de travail pour chaque entrée. Mais alors, vous avez répondu à la question d'origine.
- C'est bien, j'ai juste pensé qu'il était inutile de modifier ma réponse à cette importante gotcha parce que vous l'explique très bien. La prochaine fois, je ne vais pas être paresseux. 🙂
- merci pour cette réponse, je suis en train d'essayer quelque chose de très similaire à cette question. stackoverflow.com/questions/33692331/.... Quand je suis ajoutant des 51073+51073 je suis 153219.0 au lieu de 102,146.
- Salut, je veux ronde comme cela, si la valeur décimale est 453.65 il roun jusqu'à 454, comment le faire
InformationsquelleAutor biziclop

Live @Sergey est une solution, mais avec une division entière.

double value = 23.8764367843;
double rounded = (double) Math.round(value * 100) / 100;
System.out.println(value +" rounded is "+ rounded);

imprime

23.8764367843 rounded is 23.88

EDIT: Sergey points, il devrait y avoir aucune différence entre multipling double*int et double*double et en divisant double/int et double/double. Je ne peux pas trouver un exemple où le résultat est différent. Cependant sur x86/x64 et d'autres systèmes, il existe une machine spécifique du code d'instruction mixte, double,int valeurs qui, je crois, la JVM utilise.

for (int j = 0; j < 11; j++) {
    long start = System.nanoTime();
    for (double i = 1; i < 1e6; i *= 1.0000001) {
        double rounded = (double) Math.round(i * 100) / 100;
    }
    long time = System.nanoTime() - start;
    System.out.printf("double,int operations %,d%n", time);
}
for (int j = 0; j < 11; j++) {
    long start = System.nanoTime();
    for (double i = 1; i < 1e6; i *= 1.0000001) {
        double rounded = (double) Math.round(i * 100.0) / 100.0;
    }
    long time = System.nanoTime() - start;
    System.out.printf("double,double operations %,d%n", time);
}

Imprime

double,int operations 613,552,212
double,int operations 661,823,569
double,int operations 659,398,960
double,int operations 659,343,506
double,int operations 653,851,816
double,int operations 645,317,212
double,int operations 647,765,219
double,int operations 655,101,137
double,int operations 657,407,715
double,int operations 654,858,858
double,int operations 648,702,279
double,double operations 1,178,561,102
double,double operations 1,187,694,386
double,double operations 1,184,338,024
double,double operations 1,178,556,353
double,double operations 1,176,622,937
double,double operations 1,169,324,313
double,double operations 1,173,162,162
double,double operations 1,169,027,348
double,double operations 1,175,080,353
double,double operations 1,182,830,988
double,double operations 1,185,028,544

Où est la division entière? L'opérateur de cast a une priorité plus élevée, de sorte que vous divisez un double par un nombre entier, mais entier est promu en double dans ce cas. Donc, c'est essentiellement le même que celui de mon code. Ou la même chose que Math.round(value * 100) / 100.0. C'est juste une question de style. Si vous avez utilisé une véritable division entière, vous obtiendrez 23 comme résultat.
En théorie, vous avez raison, et peut-être que ma réponse est la JVM spécifiques, voir mon edit pour plus de détails.
génial. Le JLS stipule clairement que les entier doit être promu double dans cette division, de sorte que le résultat doit être le même dans les deux cas, en tout conforme implémentation de Java, mais je n'avais aucune idée que la JVM optimise la mise en œuvre effective d'une telle façon.
vous devez TOUJOURS définir explicitement le type de données natif à côté de votre statique les numéros de votre code source, et ne pas laisser le compilateur de décider pour vous. faites-vous? J'espère que vous ne le font pas. ceci est important lors de l'écriture de la haute performance de jeux.

InformationsquelleAutor Peter Lawrey

7

Le problème est que vous utilisez une localisation formateur qui génère les paramètres régionaux en point décimal, ce qui est "," dans votre cas. Mais Double.parseDouble() s'attend à ce non-localisée double littérale. Vous pourriez résoudre votre problème à l'aide d'une analyse spécifique aux paramètres régionaux de la méthode ou par l'évolution des paramètres régionaux de votre formateur à quelque chose qui utilise le "." comme séparateur de décimales. Ou encore mieux, éviter de mise en forme en utilisant quelque chose comme ceci:
```
double rounded = (double) Math.round(value * 100.0) / 100.0;
```
- Comment à ce sujet à venir avec 23.8764367843 => 23.88000000002? Je pense qu'une Chaîne de traitement, c'est mieux.
- eh bien, il n'y a aucun moyen que vous obtenez exactement 23.88 par l'analyse de "23.88, comme un double, soit, comme 23.88 n'est pas exactement représentable en binaire de toute façon. Si la représentation exacte est nécessaire, une sorte de précision arbitraire de la bibliothèque doit être utilisé.
- Vous avez raison, mais je pensais que nous parlions de "textuelle" et "approximative" de la représentation, et non binaire. Waldheinz et Pierre répondit que ci-dessus. DecimalFormat est un bon choix, mais au cas où cela ne fonctionne pas, j'essaierais d'une Chaîne roundedStr = String.valueOf (arrondi); int dotPoint = roundedStr.indexOf("."); retour (roundedStr).substring(0,dotPoint < 0 ? roundedStr.longueur() : dotPoint+2); Ce n'est pas tout à fait correcte, vous pourriez avoir à ajouter une marge intérieure de 0 pour le droit s'il y a seulement 1 chiffre à droite de la virgule décimale dans roundedStr - mais vous voyez l'idée de ce que je commentais plus tôt.
- si une représentation textuelle est nécessaire, alors c'est une autre histoire bien sûr. Mais alors il n'y aurait pas besoin d'analyser en arrière, je pense. En fin de compte, il dépend de la façon dont la valeur sera utilisée, bien sûr.
InformationsquelleAutor Sergei Tachenov
4

Il y a quelque chose de fondamentalement mauvais dans ce que vous essayez de faire. Variable binaire-les points ne sont pas ont décimales. Vous ne pouvez pas véritablement un tour à un nombre de décimales, parce que la plupart des "ronde" les valeurs décimales ne peut tout simplement pas être représenté comme une fraction binaire. C'est pourquoi on ne devrait jamais utiliser float ou double pour représenter de l'argent.

Donc, si vous voulez chiffres après la virgule dans le résultat, ce résultat doit être un String (dont vous avez déjà eu avec la DecimalFormat), ou un BigDecimal (qui a un setScale() méthode qui fait exactement ce que vous voulez). Sinon, le résultat ne peut pas être ce que vous voulez qu'il soit.

Lire La Virgule Flottante Guide pour plus d'informations.
- Pourrait-on imaginer qu'il avait demandé "le nombre à virgule flottante la plus proche de la valeur arrondie à deux décimales"?
- où pourrait éventuellement être utile?
InformationsquelleAutor Michael Borgwardt

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

InformationsquelleAutor Li Ying

1

Vous pourriez essayer de définir un nouveau DecimalFormat et en l'utilisant comme un Double résultat à une nouvelle variable de type double.

Exemple pour vous faire comprendre ce que je viens de dire.
```
double decimalnumber = 100.2397;
DecimalFormat dnf = new DecimalFormat( "#,###,###,##0.00" );
double roundednumber = new Double(dnf.format(decimalnumber)).doubleValue();
```
InformationsquelleAutor Markku
1

Ce n'est pas possible dans la forme requise, car il y a des nombres avec deux chiffres après la virgule qui ne peut pas être exprimée en utilisant exactement à virgule flottante IEEE de chiffres (par exemple 1/10 = 0.1 ne peut pas être exprimé comme une Double ou Float). La mise en forme doit toujours se passer comme la dernière étape avant de présenter le résultat à l'utilisateur.

Je suppose que vous demandez, parce que vous voulez traiter avec des valeurs monétaires. Il n'y a aucun moyen de le faire de manière fiable avec des nombres à virgule flottante, vous devriez envisager de passer à virgule fixe l'arithmétique. Cela signifie probablement faire tous les calculs en "cents" au lieu de "dollars".
- Bon point, si c'est vraiment un monétaire de calcul à virgule flottante est tout à fait le type de données incorrect.
- Pourriez-vous expliquer l'exemple? Pourquoi ne pouvez-vous pas représenter 1/10 comme 0.10?
- 1/10 est de 0,10 mais à virgule flottante est binaire, il n'y a pas une telle chose comme 1/10 ou 0.1. Vous avez seulement 1/2, 1/4, 1/8, etc, et toute combinaison de ces rapprochant de 0,1
- Désolé, j'étais AFK, donc je ne pouvais pas répondre à cette question dans un temps opportun. Mais bon Pierre a sauté dans. 🙂
- Ahhh, OK, vous parlez de la précision, je comprends maintenant.
InformationsquelleAutor Waldheinz

double TotalPrice=90.98989898898;

  DecimalFormat format_2Places = new DecimalFormat("0.00");

    TotalPrice = Double.valueOf(format_2Places.format(TotalPrice));

InformationsquelleAutor DeltaCap019

Vous pouvez utiliser le format comme ici,

  public static double getDoubleValue(String value,int digit){
    if(value==null){
        value="0";
     }
    double i=0;
     try {
         DecimalFormat digitformat = new DecimalFormat("#.##");
         digitformat.setMaximumFractionDigits(digit);
        return Double.valueOf(digitformat.format(Double.parseDouble(value)));

    } catch (NumberFormatException numberFormatExp) {
        return i;   
    }
}

InformationsquelleAutor Knowledge Serve

Si vous ne souhaitez pas utiliser DecimalFormat (par exemple, en raison de son efficacité) et vous souhaitez une solution générale, vous pouvez également essayer cette méthode qui utilise l'échelle arrondissement:

public static double roundToDigits(double value, int digitCount) {
    if (digitCount < 0)
        throw new IllegalArgumentException("Digit count must be positive for rounding!");

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

InformationsquelleAutor Keplerian

Vous devez vous connecter pour publier un commentaire.