Округлить до 2 десятичных знаков в java?

Я прочитал много вопросов о stackoverflow, но ни один из них не работает для меня. Я использую math.round() для округления. это код:

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

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

    System.out.println(roundOff);
}
}

вывод я get: 123, но я хочу, чтобы он был 123.14. я читал, что добавление *100/100 поможет, но, как вы можете видеть, мне не удалось заставить его работать.

абсолютно необходимо, чтобы как входные, так и выходные данные были двойными.

было бы большой помощью, если вы измените строку 4 вышеприведенного кода и разместите ее.

Ответ 1

Ну, это работает...

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

Выход

123.14

Или, как сказал @Rufein

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

это сделает это и для вас.

Ответ 2

     double d = 2.34568;
     DecimalFormat f = new DecimalFormat("##.00");
     System.out.println(f.format(d));

Ответ 3

String roundOffTo2DecPlaces(float val)
{
    return String.format("%.2f", val);
}

Ответ 4

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

Ответ 5

Вернитесь к своему коду и замените 100 на 100.00 и дайте мне знать, если он работает. Однако, если вы хотите быть формальным, попробуйте следующее:

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

Ответ 6

Я знаю, что это вопрос 2 года, но поскольку каждый орган сталкивается с проблемой, чтобы округлить значения в какой-то момент времени. Я хотел бы поделиться другим способом, который может дать нам округленные значения для любого масштаба, используя BigDecimal class. Здесь мы можем избежать дополнительных шагов, необходимых для получения окончательного значения, если мы используем DecimalFormat("0.00") или используя 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);

    }
}

Эта программа даст нам ниже выход

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

Ответ 7

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

должен быть

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

Добавление "D" в 100 делает его двойным литералом, поэтому полученный результат будет иметь точность

Ответ 8

Попробуйте:

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

Ответ 9

Это длинное, но полное доказательство, никогда не сработает

Просто передайте свой номер этой функции как двойной, он вернет вам округление десятичного значения до ближайшего значения 5;

если 4.25, выход 4.25

если 4.20, выход 4.20

если 4.24, Output 4.20

если 4.26, выход 4.30

если вы хотите округлить до двух знаков после запятой, затем используйте

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

если до 3-х мест, новый DecimalFormat ( "#. ###" )

если до n мест, новый 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))));

            }

Ответ 10

похоже, что вы попали в целочисленную арифметику: в некоторых языках (int)/(int) всегда будет оцениваться как целочисленная арифметика. чтобы принудительно выполнить арифметику с плавающей запятой, убедитесь, что хотя бы один из операндов нецелый:

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

Ответ 11

Я только что изменил ваш код. Он отлично работает в моей системе. Посмотрите, помогает ли это

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

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

    System.out.println(roundOff);
}
}

Ответ 12

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

В большинстве случаев должно быть хорошо. Вы по-прежнему можете изменять типы, если хотите, например, быть совместимыми с удвоениями.