round arredondar até 2 casas decimais em java?




não arredondar java (10)

BigDecimal a = new BigDecimal("123.13698");
BigDecimal roundOff = a.setScale(2, BigDecimal.ROUND_HALF_EVEN);
System.out.println(roundOff);

Esta questão já tem uma resposta aqui:

Eu li um monte de perguntas sobre o stackoverflow, mas nenhuma parece estar funcionando para mim. Eu estou usando math.round() para arredondar. este é o código:

class round{
    public static void main(String args[]){

    double a = 123.13698;
    double roundOff = Math.round(a*100)/100;

    System.out.println(roundOff);
}
}

a saída que recebo é: 123 mas eu quero que seja 123.14 . Eu li que adicionar *100/100 vai ajudar, mas como você pode ver eu não consegui fazê-lo funcionar.

É absolutamente essencial que tanto a entrada quanto a saída sejam duplas.

Seria de grande ajuda se você alterasse a linha 4 do código acima e a postasse.


double roundOff = Math.round(a*100)/100;

deveria estar

double roundOff = Math.round(a*100)/100D;

Adicionando 'D' a 100 faz com que seja double literal, assim o resultado produzido terá precisão


Acabei de modificar seu código. Funciona bem no meu sistema. Veja se isso ajuda

class round{
    public static void main(String args[]){

    double a = 123.13698;
    double roundOff = Math.round(a*100)/100.00;

    System.out.println(roundOff);
}
}

public static float roundFloat(float in) {
    return ((int)((in*100f)+0.5f))/100f;
}

Deve estar ok para a maioria dos casos. Você ainda pode alterar os tipos se quiser ser compatível com duplas, por exemplo.


Volte para o seu código e substitua 100 por 100.00 e deixe-me saber se funciona. No entanto, se você quiser ser formal, tente isto:

import java.text.DecimalFormat;
DecimalFormat df=new DecimalFormat("0.00");
String formate = df.format(value); 
double finalValue = (Double)df.parse(formate) ;

Eu sei que esta é uma pergunta de 2 anos, mas como todo corpo enfrenta um problema para arredondar os valores em algum momento. Eu gostaria de compartilhar uma maneira diferente que pode nos dar valores arredondados para qualquer escala usando a classe BigDecimal . pode evitar etapas extras que são necessárias para obter o valor final se usarmos DecimalFormat("0.00") ou usando Math.round(a * 100) / 100 .

import java.math.BigDecimal;

public class RoundingNumbers {
    public static void main(String args[]){
        double number = 123.13698;
        int decimalsToConsider = 2;
        BigDecimal bigDecimal = new BigDecimal(number);
        BigDecimal roundedWithScale = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP);
        System.out.println("Rounded value with setting scale = "+roundedWithScale);

        bigDecimal = new BigDecimal(number);
        BigDecimal roundedValueWithDivideLogic = bigDecimal.divide(BigDecimal.ONE,decimalsToConsider,BigDecimal.ROUND_HALF_UP);
        System.out.println("Rounded value with Dividing by one = "+roundedValueWithDivideLogic);

    }
}

Este programa nos daria abaixo da saída

Rounded value with setting scale = 123.14
Rounded value with Dividing by one = 123.14

Experimentar :

class round{
public static void main(String args[]){

double a = 123.13698;
double roundOff = Math.round(a*100)/100;
String.format("%.3f", roundOff); //%.3f defines decimal precision you want
System.out.println(roundOff);   }}

Este é um longo, mas uma solução de prova completa, nunca falha

Apenas passe seu número para essa função como um double, ele retornará arredondando o valor decimal até o valor mais próximo de 5;

se 4,25, saída 4,25

se 4,20, saída 4,20

se 4.24, saída 4.20

se 4.26, saída 4.30

Se você quiser arredondar até duas casas decimais, use

DecimalFormat df = new DecimalFormat("#.##");
roundToMultipleOfFive(Double.valueOf(df.format(number)));

se até 3 lugares, novo DecimalFormat ("#. ###")

se até n lugares, novo DecimalFormat ("#. nTimes # ")

 public double roundToMultipleOfFive(double x)
            {

                x=input.nextDouble();
                String str=String.valueOf(x);
                int pos=0;
                for(int i=0;i<str.length();i++)
                {
                    if(str.charAt(i)=='.')
                    {
                        pos=i;
                        break;
                    }
                }

                int after=Integer.parseInt(str.substring(pos+1,str.length()));
                int Q=after/5;
                int R =after%5;

                if((Q%2)==0)
                {
                    after=after-R;
                }
                else
                {
                   if(5-R==5)
                   {
                     after=after;
                   }
                   else after=after+(5-R);
                }

                       return Double.parseDouble(str.substring(0,pos+1).concat(String.valueOf(after))));

            }

Bem, esta funciona ...

double roundOff = Math.round(a * 100.0) / 100.0;

Saída é

123.14

Ou como @Rufein disse

 double roundOff = (double) Math.round(a * 100) / 100;

isso vai fazer isso por você também.


Parece que você é atingido por aritmética inteira: em algumas linguagens (int) / (int) sempre será avaliada como aritmética inteira. Para forçar a aritmética de ponto flutuante, certifique-se de que pelo menos um dos operandos não seja inteiro:

double roundOff = Math.round(a*100)/100.f;




java