Formatar Flutuar em n casas decimais

Eu preciso formatar um float para "n" casas decimais.

estava tentando BigDecimal, mas o valor de retorno não está correto ...

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
}

Preciso retornar um valor flutuante com o número de casas decimais que eu especificar.

Preciso de Floatretorno de valor nãoDouble

.

Você também pode passar o valor flutuante e usar:

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

Documentação

Dê uma olhada em DecimalFormat . Você pode usá-lo facilmente para pegar um número e atribuir um número definido de casas decimais.

Editar : Exemplo

Tente isso, isso me ajudou muito

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

O resultado será final da RodadaPreço -> 5652.26

De notar, o uso do DecimalFormatconstrutor é desencorajado. O javadoc para esta classe declara:

Em geral, não chame os construtores DecimalFormat diretamente, pois os métodos de fábrica NumberFormat podem retornar subclasses diferentes de DecimalFormat.

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

Então, o que você precisa fazer é (por exemplo):

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

Aqui está uma amostra rápida usando a DecimalFormatclasse mencionada por Nick.

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

A saída da declaração de impressão será 12.35. Observe que o arredondará para você.

Meio surpreso que ninguém apontou o caminho direto para fazê-lo, o que é bastante fácil.

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

Certamente, isso não faz o arredondamento pela metade.

Pelo que vale, o arredondamento semi-uniforme será caótico e imprevisível sempre que você misturar valores de ponto flutuante baseados em binário com aritmética da base 10. Tenho certeza que isso não pode ser feito. O problema básico é que um valor como 1.105 não pode ser representado exatamente no ponto flutuante. O valor do ponto flutuante será algo como 1.105000000000001 ou 1.104999999999999. Portanto, qualquer tentativa de realizar arredondamentos semitransparentes ocorre com erros de codificação representacional.

As implementações de ponto flutuante IEEE farão meio arredondamento, mas farão meio arredondamento binário, não arredondamento decimal. Então você provavelmente está bem

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

Essa é uma maneira muito menos profissional e muito mais cara, mas deve ser mais fácil de entender e mais útil para iniciantes.

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

Eu acho que o que você quer é

return value.toString();

e use o valor de retorno para exibir.

value.floatValue();

sempre retornará 625,3 porque é usado principalmente para calcular algo.

Eu estava procurando uma resposta para esta pergunta e depois desenvolvi um método! :) Um aviso justo, está arredondando o valor.

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