Как объединить два-два десятичных знака в Java?

Вы работаете с деньгами? Создание String а затем ее преобразование довольно замкнуто.

Используйте BigDecimal . Это обсуждалось довольно широко. У вас должен быть class 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 имеет десятичные знаки, но когда вы его конвертируете, вы возвращаетесь в двойную землю с двоичными дробными местами.

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

  double total = 1.4563; total = Math.round(total * 100); System.out.println(total / 100); 

Результат – 1,46.

Использовать это

String.format (“%. 2f”, doubleValue) // измените 2, согласно вашему требованию.

Вы можете использовать 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) 

источник: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html#round(double,%20int)

Ваш class Money может быть представлен как подclass Long или имеет член, представляющий денежную ценность как родной долго. Затем, когда вы присваиваете значения вашим экземплярам денег, вы всегда будете хранить значения, которые на самом деле являются реальными денежными значениями. Вы просто выводите свой объект Money (через метод переопределенных toString () ваших денег) с соответствующим форматированием. например, 1,25 доллара в внутреннем представлении денежного объекта составляет 125. Вы представляете деньги в виде центов, или пенсов или того, что минимальное деноминация в валюте, которую вы запечатываете, … затем отформатируйте ее на выходе. Нет, вы никогда не сможете сохранить «незаконную» денежную стоимость, например, $ 1,257.

двойное количество = 25,00;

NumberFormat formatter = new DecimalFormat (“# 0.00”);

System.out.println (formatter.format (сумма));

 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 } 

Предполагая, что сумма может быть как положительной, так и отрицательной, округление до двух знаков после запятой может использовать следующий fragment кода.

 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, вы можете сделать больше с помощью lambda-выражений и проверок на 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 обозначает количество десятичных знаков, которые мы хотим напечатать.

• Здесь мы принимаем 2 десятичных следа

  System.out.printf ( “% 2f”, Num);

Вы можете попробовать это:

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

Вот простой способ гарантировать вывод 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

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

Сначала объявите объект classа 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 и так далее.