Comment tronquer un double à deux décimales en Java? [dupliquer]

DecimalFormat df = new DecimalFormat(fmt);
df.setRoundingMode(RoundingMode.DOWN);
s = df.format(d);

contrôle disponible RoundingMode et DecimalFormat .

Forum un peu vieux, aucune de la réponse ci-dessus travaillé pour les valeurs positives et négatives ( je veux dire pour le calcul et juste de faire tronquer sans arrondi). Du comment arrondir un nombre à n décimales en Java link

private static BigDecimal truncateDecimal(double x,int numberofDecimals)
{
    if ( x > 0) {
        return new BigDecimal(String.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_FLOOR);
    } else {
        return new BigDecimal(String.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_CEILING);
    }
}

Cette méthode a bien fonctionné pour moi .

System.out.println(truncateDecimal(0, 2));
    System.out.println(truncateDecimal(9.62, 2));
    System.out.println(truncateDecimal(9.621, 2));
    System.out.println(truncateDecimal(9.629, 2));
    System.out.println(truncateDecimal(9.625, 2));
    System.out.println(truncateDecimal(9.999, 2));
    System.out.println(truncateDecimal(-9.999, 2));
    System.out.println(truncateDecimal(-9.0, 2));

Résultats :

0.00
9.62
9.62
9.62
9.62
9.99
-9.99
-9.00

notez tout d'abord qu'une double est une fraction binaire et ne fait pas vraiment ont décimales.

si vous avez besoin de décimales, utilisez un BigDecimal , qui a une méthode de setScale() pour la troncature, ou utilisez DecimalFormat pour obtenir un String .

si, pour une raison quelconque, vous ne voulez pas utiliser un BigDecimal vous pouvez lancer votre double dans un int pour la tronquer.

si vous voulez tronquer à la uns place:

• simplement moulé à int

à la dixièmes lieu:

• multiplier par dix
• int
• acteurs double
• et diviser par dix.

centièmes place

• multiplier et diviser par 100 etc.

exemple:

static double truncateTo( double unroundedNumber, int decimalPlaces ){
    int truncatedNumberInt = (int)( unroundedNumber * Math.pow( 10, decimalPlaces ) );
    double truncatedNumber = (double)( truncatedNumberInt / Math.pow( 10, decimalPlaces ) );
    return truncatedNumber;
}

dans cet exemple, decimalPlaces serait le nombre de places au-delà de celui que vous souhaitez aller, donc 1 serait autour de la dixièmes , 2 pour centièmes , et ainsi de suite (0 tours à la la place, et négatif pour les dizaines, etc.)

peut-être Math.floor(value * 100) / 100 ? Attention, les valeurs comme 3.54 peuvent ne pas être représentées exactement avec un double .

vous pouvez utiliser L'objet de classe NumberFormat pour accomplir la tâche.

// Creating number format object to set 2 places after decimal point
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);            
nf.setGroupingUsed(false);

System.out.println(nf.format(precision));// Assuming precision is a double type variable

3.545555555 pour obtenir 3.54. Essayez de suivre pour cela:

    DecimalFormat df = new DecimalFormat("#.##");

    df.setRoundingMode(RoundingMode.FLOOR);

    double result = new Double(df.format(3.545555555);

donne = 3,54!

former comme une chaîne et convertir de nouveau en double je pense que vous donnera le résultat que vous voulez.

la valeur double ne sera pas ronde(), floor() ou ceil().

une solution rapide pour elle pourrait être:

 String sValue = (String) String.format("%.2f", oldValue);
 Double newValue = Double.parseDouble(sValue);

vous pouvez utiliser la valeur S pour l'affichage ou la nouvelle valeur pour le calcul.

Voici la méthode que j'utilise:

double a=3.545555555; // just assigning your decimal to a variable
a=a*100;              // this sets a to 354.555555
a=Math.floor(a);      // this sets a to 354
a=a/100;              // this sets a to 3.54 and thus removing all your 5's

cela peut aussi être fait:

a=Math.floor(a*100) / 100;

peut-être le suivant:

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

Une vérification rapide est d'utiliser les Mathématiques.étage méthode. J'ai créé une méthode pour vérifier un double pour deux décimales ou moins ci-dessous:

public boolean checkTwoDecimalPlaces(double valueToCheck) {

    // Get two decimal value of input valueToCheck 
    double twoDecimalValue = Math.floor(valueToCheck * 100) / 100;

    // Return true if the twoDecimalValue is the same as valueToCheck else return false
    return twoDecimalValue == valueToCheck;
}

//if double_v is 3.545555555
String string_v= String.valueOf(double_v);
int pointer_pos = average.indexOf('.');//we find the position of '.'
string_v.substring(0, pointer_pos+2));// in this way we get the double with only 2 decimal in string form
double_v = Double.valueOf(string_v);//well this is the final result

Eh bien, cela pourrait être un peu maladroit, mais je pense que cela peut résoudre votre problème :)

j'ai une version légèrement modifiée de Mani .

private static BigDecimal truncateDecimal(final double x, final int numberofDecimals) {
    return new BigDecimal(String.valueOf(x)).setScale(numberofDecimals, BigDecimal.ROUND_DOWN);
}

public static void main(String[] args) {
    System.out.println(truncateDecimal(0, 2));
    System.out.println(truncateDecimal(9.62, 2));
    System.out.println(truncateDecimal(9.621, 2));
    System.out.println(truncateDecimal(9.629, 2));
    System.out.println(truncateDecimal(9.625, 2));
    System.out.println(truncateDecimal(9.999, 2));
    System.out.println(truncateDecimal(3.545555555, 2));

    System.out.println(truncateDecimal(9.0, 2));
    System.out.println(truncateDecimal(-9.62, 2));
    System.out.println(truncateDecimal(-9.621, 2));
    System.out.println(truncateDecimal(-9.629, 2));
    System.out.println(truncateDecimal(-9.625, 2));
    System.out.println(truncateDecimal(-9.999, 2));
    System.out.println(truncateDecimal(-9.0, 2));
    System.out.println(truncateDecimal(-3.545555555, 2));

}

sortie:

0.00
9.62
9.62
9.62
9.62
9.99
9.00
3.54
-9.62
-9.62
-9.62
-9.62
-9.99
-9.00
-3.54

cela a fonctionné pour moi:

double input = 104.8695412  //For example

long roundedInt = Math.round(input * 100);
double result = (double) roundedInt/100;

//result == 104.87

j'aime personnellement cette version parce qu'elle effectue l'arrondissement numériquement, plutôt que de la convertir en chaîne (ou similaire) et de la formater.