Это то, что я сделал для округления до двух знаков после запятой:
amount = roundTwoDecimals(amount);
public double roundTwoDecimals(double d) {
DecimalFormat twoDForm = new DecimalFormat("#.##");
return Double.valueOf(twoDForm.format(d));
}
Это отлично работает, если сумма = 25.3569 или что-то в этом роде, но если сумма = 25.00 или сумма = 25.0, тогда я получаю 25.0! Я хочу как округлять, так и форматировать до двух знаков после запятой.
Вы работаете с деньгами? Создание String, а затем его преобразование довольно замкнуто.
Используйте BigDecimal. Это обсуждалось довольно широко. У вас должен быть класс Money, а сумма должна быть BigDecimal.
Даже если вы не работаете с деньгами, рассмотрите BigDecimal.
Просто используйте: (просто как пирог)
double number = 651.5176515121351;
number = Math.round(number * 100);
number = number/100;
Выход будет 651,52
Используйте держатель цифр (0), так как "#" конечные/ведущие нули показывают как отсутствующие:
DecimalFormat twoDForm = new DecimalFormat("#.00");
Вы не можете "удвоить число до [число] десятичных знаков", потому что у парных разрядов нет десятичных знаков. Вы можете преобразовать double в base-10 String с N знаками после запятой, потому что base-10 имеет десятичные знаки, но когда вы его переводите обратно, вы возвращаетесь в двойную землю с двоичными дробными местами.
Используйте этот
String.format( "%. 2f", doubleValue)//измените 2, согласно вашему требованию.
Это самый простой способ, которым я мог бы это сделать, но он делает работу намного проще, чем большинство рассмотренных примеров.
double total = 1.4563;
total = Math.round(total * 100);
System.out.println(total / 100);
Результат равен 1.46.
Вы можете использовать org.apache.commons.math.util.MathUtils из apache common
double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);
Вы можете использовать Apache Commons Math:
Precision.round(double x, int scale)
Ваш класс Money может быть представлен как подкласс Long или имеющий член, представляющий денежную стоимость как родной. Затем, когда вы присваиваете значения вашим экземплярам денег, вы всегда будете хранить значения, которые на самом деле являются реальными денежными значениями. Вы просто выводите свой объект Money (через метод Money overridden toString()) с соответствующим форматированием. например, 1,25 доллара в внутреннем представлении "Денежный объект" составляет 125. Вы представляете деньги в виде центов, или пенсов, или как минимальное деноминация в валюте, которую вы запечатываете,... затем отформатируйте ее на выходе. Нет, вы никогда не сможете сохранить "незаконную" денежную стоимость, например, $1.257.
двойное количество = 25,00;
NumberFormat formatter = new DecimalFormat ( "# 0.00" );
System.out.println(formatter.format(сумма));
Вы можете попробовать следующее:
public static String getRoundedValue(Double value, String format) {
DecimalFormat df;
if(format == null)
df = new DecimalFormat("#.00");
else
df = new DecimalFormat(format);
return df.format(value);
}
или
public static double roundDoubleValue(double value, int places) {
if (places < 0) throw new IllegalArgumentException();
long factor = (long) Math.pow(10, places);
value = value * factor;
long tmp = Math.round(value);
return (double) tmp / factor;
}
DecimalFormat df = new DecimalFormat("###.##");
double total = Double.valueOf(val);
Если вы хотите, чтобы результат был равен двум десятичным знакам, вы можете сделать
// assuming you want to round to Infinity.
double tip = (long) (amount * percent + 0.5) / 100.0;
Этот результат не является точным, но Double.toString(double) будет исправлять это и печатать от одного до двух знаков после запятой. Однако, как только вы выполните другой расчет, вы можете получить результат, который не будет неявно округлен.;)
Math.round - один ответ,
public class Util {
public static Double formatDouble(Double valueToFormat) {
long rounded = Math.round(valueToFormat*100);
return rounded/100.0;
}
}
void "test double format"(){
given:
Double performance = 0.6666666666666666
when:
Double formattedPerformance = Util.formatDouble(performance)
println "######################## formatted ######################### => ${formattedPerformance}"
then:
0.67 == formattedPerformance
}
Предполагая, что сумма может быть как положительной, так и отрицательной, округление до двух знаков после запятой может использовать следующий фрагмент кода.
amount = roundTwoDecimals(amount);
public double roundTwoDecimals(double d) {
if (d < 0)
d -= 0.005;
else if (d > 0)
d += 0.005;
return (double)((long)(d * 100.0))/100);
}
Запустив java 1.8, вы можете делать больше с лямбда-выражениями и проверять значение null. Кроме того, один ниже может обрабатывать Float или Double и переменное число десятичных точек (включая 2: -)).
public static Double round(Number src, int decimalPlaces) {
return Optional.ofNullable(src)
.map(Number::doubleValue)
.map(BigDecimal::new)
.map(dbl -> dbl.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP))
.map(BigDecimal::doubleValue)
.orElse(null);
}
где num - это двойной номер
Здесь мы берем 2 десятичных паллета
System.out.printf( "% 2f"., Кол-во);
Вот простой способ гарантировать вывод myFixedNumber с округлением до двух знаков после запятой:
import java.text.DecimalFormat;
public class TwoDecimalPlaces {
static double myFixedNumber = 98765.4321;
public static void main(String[] args) {
System.out.println(new DecimalFormat("0.00").format(myFixedNumber));
}
}
Результат: 98765.43
Сначала объявите объект класса DecimalFormat. Обратите внимание, что аргумент внутри DecimalFormat равен #.00, что означает ровно 2 десятичных знака округления.
private static DecimalFormat df2 = new DecimalFormat("#.00");
Теперь примените формат к вашему двойному значению:
double input = 32.123456;
System.out.println("double : " + df2.format(input)); // Output: 32.12
Примечание в случае double input = 32.1;
Тогда вывод будет 32.10 и т.д.
int i = 180;
int j = 1;
double div= ((double)(j*100)/i);
DecimalFormat df = new DecimalFormat("#.00"); // simple way to format till any deciaml points
System.out.println(div);
System.out.println(df.format(div));
Вы можете использовать эту функцию.
import org.apache.commons.lang.StringUtils;
public static double roundToDecimals(double number, int c)
{
String rightPad = StringUtils.rightPad("1", c+1, "0");
int decimalPoint = Integer.parseInt(rightPad);
number = Math.round(number * decimalPoint);
return number/decimalPoint;
}