Ответ 1
Ну, это работает...
double roundOff = Math.round(a * 100.0) / 100.0;
Выход
123.14
Или, как сказал @Rufein
double roundOff = (double) Math.round(a * 100) / 100;
это сделает это и для вас.
Я прочитал много вопросов о 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 вышеприведенного кода и разместите ее.
Ну, это работает...
double roundOff = Math.round(a * 100.0) / 100.0;
Выход
123.14
Или, как сказал @Rufein
double roundOff = (double) Math.round(a * 100) / 100;
это сделает это и для вас.
double d = 2.34568;
DecimalFormat f = new DecimalFormat("##.00");
System.out.println(f.format(d));
String roundOffTo2DecPlaces(float val)
{
return String.format("%.2f", val);
}
BigDecimal a = new BigDecimal("123.13698");
BigDecimal roundOff = a.setScale(2, BigDecimal.ROUND_HALF_EVEN);
System.out.println(roundOff);
Вернитесь к своему коду и замените 100
на 100.00
и дайте мне знать, если он работает.
Однако, если вы хотите быть формальным, попробуйте следующее:
import java.text.DecimalFormat;
DecimalFormat df=new DecimalFormat("0.00");
String formate = df.format(value);
double finalValue = (Double)df.parse(formate) ;
Я знаю, что это вопрос 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
double roundOff = Math.round(a*100)/100;
должен быть
double roundOff = Math.round(a*100)/100D;
Добавление "D" в 100 делает его двойным литералом, поэтому полученный результат будет иметь точность
Попробуйте:
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); }}
Это длинное, но полное доказательство, никогда не сработает
Просто передайте свой номер этой функции как двойной, он вернет вам округление десятичного значения до ближайшего значения 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))));
}
похоже, что вы попали в целочисленную арифметику: в некоторых языках (int)/(int) всегда будет оцениваться как целочисленная арифметика. чтобы принудительно выполнить арифметику с плавающей запятой, убедитесь, что хотя бы один из операндов нецелый:
double roundOff = Math.round(a*100)/100.f;
Я только что изменил ваш код. Он отлично работает в моей системе. Посмотрите, помогает ли это
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;
}
В большинстве случаев должно быть хорошо. Вы по-прежнему можете изменять типы, если хотите, например, быть совместимыми с удвоениями.