Formater le flottant à n décimales

J'ai besoin de formater un flotteur à "n" décimales.

essayait de BigDecimal, mais la valeur de retour n'est pas correcte ...

public static float Redondear(float pNumero, int pCantidadDecimales) {
    // the function is call with the values Redondear(625.3f, 2)
    BigDecimal value = new BigDecimal(pNumero);
    value = value.setScale(pCantidadDecimales, RoundingMode.HALF_EVEN); // here the value is correct (625.30)
    return value.floatValue(); // but here the values is 625.3
}

J'ai besoin de renvoyer une valeur flottante avec le nombre de décimales que je spécifie.

J'ai besoin d'un Floatretour de valeur nonDouble

.

Vous pouvez également transmettre la valeur flottante et utiliser:

String.format("%.2f", floatValue);

Documentation

Jetez un oeil à DecimalFormat . Vous pouvez facilement l'utiliser pour prendre un nombre et lui donner un nombre défini de décimales.

Modifier : Exemple

Essayez ceci, cela m'a beaucoup aidé

BigDecimal roundfinalPrice = new BigDecimal(5652.25622f).setScale(2,BigDecimal.ROUND_HALF_UP);

Le résultat sera ronde finalePrix -> 5652.26

Il est à noter que l'utilisation du DecimalFormatconstructeur est déconseillée. Le javadoc de cette classe indique:

En général, n'appelez pas directement les constructeurs DecimalFormat, car les méthodes de fabrique NumberFormat peuvent renvoyer des sous-classes autres que DecimalFormat.

https://docs.oracle.com/javase/8/docs/api/java/text/DecimalFormat.html

Donc, ce que vous devez faire est (par exemple):

NumberFormat formatter = NumberFormat.getInstance(Locale.US);
formatter.setMaximumFractionDigits(2);
formatter.setMinimumFractionDigits(2);
formatter.setRoundingMode(RoundingMode.HALF_UP); 
Float formatedFloat = new Float(formatter.format(floatValue));

Voici un exemple rapide utilisant la DecimalFormatclasse mentionnée par Nick.

float f = 12.345f;
DecimalFormat df = new DecimalFormat("#.00");
System.out.println(df.format(f));

La sortie de l'instruction print sera 12,35. Notez qu'il l'arrondira pour vous.

Un peu surpris que personne n'ait indiqué la manière directe de le faire, ce qui est assez facile.

double roundToDecimalPlaces(double value, int decimalPlaces)
{
      double shift = Math.pow(10,decimalPlaces);
      return Math.round(value*shift)/shift;
}

Je suis sûr que cela ne permet pas d'arrondir à moitié même.

Pour ce que ça vaut, l'arrondi demi-pair va être chaotique et imprévisible à chaque fois que vous mélangez des valeurs à virgule flottante basées sur des binaires avec l'arithmétique de base 10. Je suis sûr que cela ne peut pas être fait. Le problème de base est qu'une valeur comme 1.105 ne peut pas être représentée exactement en virgule flottante. La valeur à virgule flottante sera quelque chose comme 1.105000000000001 ou 1.104999999999999. Ainsi, toute tentative d'effectuer un arrondi demi-pair entraîne des erreurs de codage de représentation.

Les implémentations en virgule flottante IEEE feront un demi-arrondi, mais elles feront un demi-arrondi binaire, pas un demi-arrondi décimal. Donc tu vas probablement bien

public static double roundToDouble(float d, int decimalPlace) {
        BigDecimal bd = new BigDecimal(Float.toString(d));
        bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
        return bd.doubleValue();
    }

C'est un moyen beaucoup moins professionnel et beaucoup plus cher, mais il devrait être plus facile à comprendre et plus utile pour les débutants.

public static float roundFloat(float F, int roundTo){

    String num = "#########.";

    for (int count = 0; count < roundTo; count++){
        num += "0";
    }

    DecimalFormat df = new DecimalFormat(num);

    df.setRoundingMode(RoundingMode.HALF_UP);

    String S = df.format(F);
    F = Float.parseFloat(S);

    return F;
}

Je pense que ce que tu veux

return value.toString();

et utilisez la valeur de retour pour afficher.

value.floatValue();

renverra toujours 625,3 car il est principalement utilisé pour calculer quelque chose.

Je cherchais une réponse à cette question et plus tard j'ai développé une méthode! :) Un avertissement juste, c'est arrondir la valeur.

private float limitDigits(float number) {
    return Float.valueOf(String.format(Locale.getDefault(), "%.2f", number));
}