Garniture de Plus de deux Zéros à droite dans BigDecimal

Ce serait une bonne façon de couper plus de deux zéros pour un BigDecimal

Donc 1.2200 serait d'imprimer 1.22 et 1,0000 serait d'imprimer 1.00

Modifier ainsi Que le retour 1.222200 comme
1.2222 et 1.220000001 comme 1.220000001 etc. Donc, ignorant les deux premiers zéros je veux couper les entrants 0 et de ne pas découper les valeurs non nulles

Une façon peut être de se multiplier, puis appliquer le construit en garniture de zéros à droite et puis à diviser par 100. Il pourrait être difficile dans le cas du coin mais les valeurs de mon problème de monnaie de base et ne jamais dépasser les limites fixées par Java (ou autre chose, elle signifie que mon logiciel est de traiter avec les offres qui sont dans gazzilions de dollars)

Le laid solution est comme épouse

System.out.println(((new BigDecimal("1.230223000")
                                 .multiply(new BigDecimal("100.0"))
                                 .stripTrailingZeros()).divide(new BigDecimal("100.0"))));

notez que vos nouvelles exigences en conflit avec vos originaux: comment peut - 1.230223000 être transformé en 1.230223, mais 1.0000 doit imprimer 1.00?
aucune d'elles ne Joachim. lire de nouveau. Je veux ignorer les deux premiers zéros après la virgule pour le découpage. Et l'entrée sera toujours de atleast x.xx type
yep, j'ai réalisé qu'après que j'ai posté mon commentaire. Est-ce que mon (mise à jour) réponse de l'aide?

InformationsquelleAutor geoaxis | 2011-05-30

bigdecimal java

Le vérifier,

import java.text.DecimalFormat;
import java.text.NumberFormat;

public class DecimalFormatExample
{
  public static void main(String args[])
  {
  double amount = 2192.015;
  NumberFormat formatter = new DecimalFormat("#0.00");
  System.out.println("The Decimal Value is:"+formatter.format(amount));
  }
}

Ce sera tronquée, new BigDecimal("1.234") qui (selon les besoins) doit être imprimé dans son intégralité.

InformationsquelleAutor Max

13

Mise à jour: le fait de les Avoir mélangé les exigences (c'est à dire au moins 2 chiffres après le point décimal doit être affiché, mais comme beaucoup que nécessaire) n'est pas trivialement mis en œuvre, mais vous pouvez venir près:

Combiner stripTrailingZeros() avec DecimalFormat pour obtenir le comportement souhaité (ou presque):
```
DecimalFormat df = new DecimalFormat("0.00########")
String formatted = df.format(bigDecimal.stripTrailingZeros())
```
Ce sera le format tout BigDecimal valeur avec au moins 2 chiffres après le point décimal et jusqu'à 10 chiffres après la virgule, si elle améliore la précision.

BigDecimal valeurs avec plus de 10 chiffres après le point décimal sera toujours coupé:
```
 d'entrée | sortie 
-----------------+---------- 
1.20000 | 1.20 
1.23000 | 1.23 
1.2301 | 1.2301 
1.230001000 | 1.230001 
1.2300000000001 | 1.23 
```
Réponse originale à cette question:

Si vous voulez toujours avoir exactement 2 chiffres après la virgule et sachez que vous ne perdrez pas de précision de cette façon, vous pouvez appeler setScale(2, RoundingMode.INUTILE):
```
System.out.println(new BigDecimal("1.23000").setScale(2, RoundingMode.UNNECESSARY));
```
Ce code affichera 1.23. Notez que cette va lancer une ArithmeticException lors de l'arrondissement serait nécessaire (c'est à dire quoi que ce soit après les 2 premiers chiffres n'est pas nul).

Si vos valeurs peuvent avoir une plus grande précision et que vous souhaitez appliquer quelques erreurs, il suffit de remplacer RoundingMode.UNNECESSARY avec la valeur appropriée:
```
System.out.println(new BigDecimal("1.2301").setScale(2, RoundingMode.CEILING));
```
Cette impression sera 1.24.

Si vous ne connaissez pas le nombre exact de chiffres, mais qui veulent aussi peu que possible (c'est à dire que vous voulez le plus petit possible scale pour votre BigDecimal), puis de l'appel stripTrailingZeros() permettra de faire exactement ce que vous voulez:
```
System.out.println(new BigDecimal("1.230001000").stripTrailingZeros();
```
Cette impression sera 1.230001.
- Note: ma réponse suppose que vous avez besoin de la valeur. Si vous que voulez formater la valeur est affichée, alors la réponse par @Max est plus approprié.
- Je n'ai besoin de la valeur, et je veux aussi qu'il travail pour le cas suivant BigDecimal 1.230002000000 retourne BigDecimal 1.230002
- J'ai mis à jour ma réponse à ces nouvelles exigences.
InformationsquelleAutor Joachim Sauer

Cette méthode vous donnera le résultat que vous souhaitez (monétaire tour):
(qu'est-ce que la Chaîne parce que c'est mieux pour BigDecimal voir la documentation)

public static float roundUp(String what, int howmuch) throws Exception{

    try {
        return (new BigDecimal(what).setScale(howmuch, BigDecimal.ROUND_UP)).floatValue();
    } catch (NumberFormatException nfe) {
        throw new Exception("BigDecimal cannot parse value : " + what, nfe);
    }
}

InformationsquelleAutor EricParis16

Si c'est pour l'affichage des fins d'utilisation:

BigDecimal d = new BigDecimal("1.2200");
NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US);
String s = n.format(d.doubleValue());

InformationsquelleAutor Till

Pour la sortie comme String, utilisez DecimalFormat.

Sinon, utilisez ceci:

public static BigDecimal stripToMinimumScale(BigDecimal value, 
                                             final int minimumScale) {
  if (value.scale() == minimumScale) //Already correct scale
    return value;
  else {
    value = value.stripTrailingZeros();
    return (value.scale() < minimumScale) ?  
        value.setScale(minimumScale) : //Too few decimals, needs zero pad
        value; //Do not round any significant digits
  }
}

InformationsquelleAutor Mattias Jiderhamn

-1
```
BigDecimal d = new BigDecimal("59.0000");
String d1 = new DecimalFormat().format(d);
System.out.println("d1 is " + d1);
```
- cette réponse a déjà été posté, et ne tombe pas dans le champ d'application de "pistolet le plus rapide de l'ouest"
InformationsquelleAutor Reju Koshy

Vous devez vous connecter pour publier un commentaire.