Предполагая, что value - это double, вы можете:

(double)Math.round(value * 100000d) / 100000d

Это для 5-значной точности. Количество нулей указывает количество десятичных знаков.

double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;

Используйте setRoundingMode, установите RoundingMode явно для обработки вашей проблемы с половинным четным раундом, а затем используйте шаблон формата для требуемого вывода.

Пример:

DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
    Double d = n.doubleValue();
    System.out.println(df.format(d));
}

дает результат:

12
123.1235
0.23
0.1
2341234.2125

РЕДАКТИРОВАТЬ: исходный ответ не касается точности значений типа double. Это нормально, если вам все равно, округляется оно в большую или меньшую сторону. Но если вам нужно точное округление, вам нужно принять во внимание ожидаемую точность значений. Значения с плавающей запятой имеют внутреннее двоичное представление. Это означает, что такое значение, как 2,7735, на самом деле не имеет такого точного значения внутри. Он может быть чуть больше или чуть меньше. Если внутреннее значение немного меньше, оно не будет округлено до 2,7740. Чтобы исправить эту ситуацию, вам необходимо знать о точности значений, с которыми вы работаете, и добавлять или вычитать это значение перед округлением. Например, если вы знаете, что ваши значения являются точными до 6 цифр, то для округления половинных значений в большую сторону добавьте эту точность к значению:

Double d = n.doubleValue() + 1e-6;

Чтобы округлить, вычтите точность.

Вы также можете использовать

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

чтобы убедиться, что у вас есть завершающие 0.

new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);

даст вам BigDecimal. Чтобы получить строку, просто вызовите метод BigDecimaltoString или метод toPlainString для Java 5+ для строки в простом формате.

Пример программы:

package trials;
import java.math.BigDecimal;

public class Trials {

    public static void main(String[] args) {
        int yourScale = 10;
        System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
    }

Практическое руководство по Java от Real сообщения - это решение, которое также совместимо с версиями до Java 1.6.

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();

ОБНОВЛЕНИЕ: BigDecimal.ROUND_HALF_UP устарел - используйте RoundingMode

BigDecimal bd = new BigDecimal(Double.toString(number));
bd = bd.setScale(decimalPlaces, RoundingMode.HALF_UP);
return bd.doubleValue();

Предположим, у вас есть

double d = 9232.129394d;

вы можете использовать BigDecimal

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();

или без BigDecimal

d = Math.round(d*100)/100.0d;

с обоими решениями d == 9232.13

Вы можете использовать следующий служебный метод:

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}

@Milhous: десятичный формат для округления отличный:

You can also use the

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

to make sure you have the trailing 0's.

Я бы добавил, что этот метод очень хорош в обеспечении реального числовой, механизм округления - не только визуально, но и при обработке.

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

DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);

вернется как вывод: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);

вернется как вывод: 0.91239

DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);

вернется как вывод: 0.9124

[Обновлено: также, если формат каретки такой ("# 0. ############") и вы введите десятичную дробь, например 3.1415926, для аргументации DecimalFormat не производит мусора (например, завершающие нули) и вернет: 3.1415926 .. если ты к этому склоняешься. Конечно, это немного многословно на усмотрение некоторых разработчиков - но, эй, у него мало памяти во время обработки и очень легко реализовать.]

По сути, прелесть DecimalFormat в том, что он одновременно обрабатывает строку внешний вид - а также установленный уровень точности округления. Ergo: ты получите два преимущества по цене одной реализации кода. ;)

Если вам действительно нужны десятичные числа для вычислений (и не только для вывода), не используйте двоичный формат с плавающей запятой, такой как double.

Use BigDecimal or any other decimal-based format.

Я использую BigDecimal для вычислений, но имейте в виду, что это зависит от размера числа, с которыми вы имеете дело. В большинстве своих реализаций я нахожу синтаксический анализ от double или Целого числа в Long достаточно для вычислений очень большого числа.

На самом деле я недавно использовал parsed-to-Long для получения точных представлений (в отличие от шестнадцатеричных результатов) в графическом интерфейсе для чисел размером до ############################### символов (как пример).

В приведенном ниже фрагменте кода показано, как отображать n цифр. Уловка состоит в том, чтобы установить для переменной pp значение 1, за которым следует n нулей. В приведенном ниже примере значение переменной pp имеет 5 нулей, поэтому будет отображаться 5 цифр.

double pp = 10000;

double myVal = 22.268699999999967;
String needVal = "22.2687";

double i = (5.0/pp);

String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();

Вы можете использовать класс DecimalFormat.

double d = 3.76628729;

DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal =  Double.valueOf(newFormat.format(d));

Как отмечали некоторые другие, правильный ответ - использовать DecimalFormat или BigDecimal. Плавающая точка не имеет десятичных знаков имеют, поэтому вы не можете округлить / усечь их до определенного количества. Вы должны работать с десятичной системой счисления, и это то, что делают эти два класса.

Я публикую следующий код в качестве контрпримера ко всем ответам в этом потоке и, действительно, во всем StackOverflow (и в других местах), которые рекомендуют умножение с последующим усечением с последующим делением. Сторонники этого метода обязаны объяснить, почему следующий код дает неправильный результат более чем в 92% случаев.

public class RoundingCounterExample
{

    static float roundOff(float x, int position)
    {
        float a = x;
        double temp = Math.pow(10.0, position);
        a *= temp;
        a = Math.round(a);
        return (a / (float)temp);
    }

    public static void main(String[] args)
    {
        float a = roundOff(0.0009434f,3);
        System.out.println("a = "+a+" (a % .001) = "+(a % 0.001));
        int count = 0, errors = 0;
        for (double x = 0.0; x < 1; x += 0.0001)
        {
            count++;
            double d = x;
            int scale = 2;
            double factor = Math.pow(10, scale);
            d = Math.round(d * factor) / factor;
            if ((d % 0.01) != 0.0)
            {
                System.out.println(d + " " + (d % 0.01));
                errors++;
            }
        }
        System.out.println(count + " trials " + errors + " errors");
    }
}

Вывод этой программы:

10001 trials 9251 errors

Обновлено: Чтобы ответить на некоторые комментарии ниже, я переделал модульную часть тестового цикла, используя BigDecimal и new MathContext(16) для операции модуля следующим образом:

public static void main(String[] args)
{
    int count = 0, errors = 0;
    int scale = 2;
    double factor = Math.pow(10, scale);
    MathContext mc = new MathContext(16, RoundingMode.DOWN);
    for (double x = 0.0; x < 1; x += 0.0001)
    {
        count++;
        double d = x;
        d = Math.round(d * factor) / factor;
        BigDecimal bd = new BigDecimal(d, mc);
        bd = bd.remainder(new BigDecimal("0.01"), mc);
        if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
        {
            System.out.println(d + " " + bd);
            errors++;
        }
    }
    System.out.println(count + " trials " + errors + " errors");
}

Результат:

10001 trials 4401 errors

Попробуйте это: org.apache.commons.math3.util.Precision.round (двойной x, масштаб int)

См .: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

Домашняя страница библиотеки математики Apache Commons: http://commons.apache.org/proper/commons-math/index.html

Внутренняя реализация этого метода:

public static double round(double x, int scale) {
    return round(x, scale, BigDecimal.ROUND_HALF_UP);
}

public static double round(double x, int scale, int roundingMethod) {
    try {
        return (new BigDecimal
               (Double.toString(x))
               .setScale(scale, roundingMethod))
               .doubleValue();
    } catch (NumberFormatException ex) {
        if (Double.isInfinite(x)) {
            return x;
        } else {
            return Double.NaN;
        }
    }
}

Где дп = десятичный разряд, который вы хотите, а ценить - это двойник.

    double p = Math.pow(10d, dp);

    double result = Math.round(value * p)/p;

Вы можете использовать BigDecimal

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);

См .: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/

Если вы используете DecimalFormat для преобразования double в String, это очень просто:

DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);

double num = 1.234567;
return formatter.format(num);

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

Вот краткое изложение того, что вы можете использовать, если хотите получить результат в виде String:

1. DecimalFormat # setRoundingMode ():

   DecimalFormat df = new DecimalFormat("#.#####");
   df.setRoundingMode(RoundingMode.HALF_UP);
   String str1 = df.format(0.912385)); // 0.91239
   

2. BigDecimal # setScale ()

   String str2 = new BigDecimal(0.912385)
       .setScale(5, BigDecimal.ROUND_HALF_UP)
       .toString();
   

Вот предложение, какие библиотеки вы можете использовать, если вам нужен double. Однако я бы не рекомендовал его для преобразования строк, поскольку double может не представлять то, что вы хотите точно (см., Например, здесь):

1. Точность из Apache Commons Math

   double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);
   

2. Функции от Colt

   double rounded = Functions.round(0.00001).apply(0.912385)
   

3. Утилиты от Weka

   double rounded = Utils.roundDouble(0.912385, 5)
   

Я согласен с выбранным ответом на использование DecimalFormat --- или в качестве альтернативы BigDecimal.

Пожалуйста, сначала прочтите Обновлять ниже!

Однако, если вы делать хотите округлить двойное значение и получить результат значения double, вы можете использовать org.apache.commons.math3.util.Precision.round(..), как упомянуто выше. Реализация использует BigDecimal, работает медленно и создает мусор.

Аналогичный, но быстрый и свободный от мусора метод предоставляется утилитой DoubleRounder в библиотеке decimal4j:

 double a = DoubleRounder.round(2.0/3.0, 3);
 double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
 double c = DoubleRounder.round(1000.0d, 17);
 double d = DoubleRounder.round(90080070060.1d, 9);
 System.out.println(a);
 System.out.println(b);
 System.out.println(c);
 System.out.println(d);

Будет выводить

 0.667
 0.666
 1000.0
 9.00800700601E10

Видеть https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

Заявление об ограничении ответственности: Я участвую в проекте decimal4j.

Обновлять: Как отметил @iaforek, DoubleRounder иногда возвращает нелогичные результаты. Причина в том, что он выполняет математически правильное округление. Например, DoubleRounder.round(256.025d, 2) будет округлен до 256,02, потому что двойное значение, представленное как 256.025d, несколько меньше рационального значения 256.025 и, следовательно, будет округлено в меньшую сторону.

Заметки:

• Это поведение очень похоже на поведение конструктора BigDecimal(double) (но не на valueOf(double), который использует конструктор строк).
• Проблему можно обойти с помощью двойного шага округления до более высокой точности, но это сложно, и я не буду вдаваться в подробности здесь.

По этим причинам и всему, что упомянуто выше в этом посте, я не могу рекомендовать использовать DoubleRounder.

На всякий случай кому-то еще нужна помощь с этим. Это решение отлично работает для меня.

private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals,  BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();

}

возвращает String с желаемым результатом.

Поскольку я не нашел полного ответа на эту тему, я собрал класс, который должен справиться с этим должным образом, с поддержкой:

• Форматирование: легко преобразовать двойную строку в строку с определенным количеством десятичных знаков.
• Парсинг: разобрать отформатированное значение до удвоения
• Locale: форматирование и анализ с использованием локали по умолчанию
• Экспоненциальная запись: начать использовать экспоненциальную запись после определенного порога

Использование довольно простое:

(Для этого примера я использую настраиваемый языковой стандарт)

public static final int DECIMAL_PLACES = 2;

NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);

String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"

double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345

Вот класс:

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;

public class NumberFormatter {

    private static final String SYMBOL_INFINITE           = "\u221e";
    private static final char   SYMBOL_MINUS              = '-';
    private static final char   SYMBOL_ZERO               = '0';
    private static final int    DECIMAL_LEADING_GROUPS    = 10;
    private static final int    EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
    private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation

    private DecimalFormat decimalFormat;
    private DecimalFormat decimalFormatLong;
    private DecimalFormat exponentialFormat;

    private char groupSeparator;

    public NumberFormatter(int decimalPlaces) {
        configureDecimalPlaces(decimalPlaces);
    }

    public void configureDecimalPlaces(int decimalPlaces) {
        if (decimalPlaces <= 0) {
            throw new IllegalArgumentException("Invalid decimal places");
        }

        DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
        separators.setMinusSign(SYMBOL_MINUS);
        separators.setZeroDigit(SYMBOL_ZERO);

        groupSeparator = separators.getGroupingSeparator();

        StringBuilder decimal = new StringBuilder();
        StringBuilder exponential = new StringBuilder("0.");

        for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
            decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
        }

        for (int i = 0; i < decimalPlaces; i++) {
            decimal.append("#");
            exponential.append("0");
        }

        exponential.append("E0");

        decimalFormat = new DecimalFormat(decimal.toString(), separators);
        decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
        exponentialFormat = new DecimalFormat(exponential.toString(), separators);

        decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
        decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
        exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
    }

    public String format(double value) {
        String result;
        if (Double.isNaN(value)) {
            result = "";
        } else if (Double.isInfinite(value)) {
            result = String.valueOf(SYMBOL_INFINITE);
        } else {
            double absValue = Math.abs(value);
            if (absValue >= 1) {
                if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
                    value = Math.floor(value);
                    result = exponentialFormat.format(value);
                } else {
                    result = decimalFormat.format(value);
                }
            } else if (absValue < 1 && absValue > 0) {
                if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
                    result = decimalFormat.format(value);
                    if (result.equalsIgnoreCase("0")) {
                        result = decimalFormatLong.format(value);
                    }
                } else {
                    result = exponentialFormat.format(value);
                }
            } else {
                result = "0";
            }
        }
        return result;
    }

    public String formatWithoutGroupSeparators(double value) {
        return removeGroupSeparators(format(value));
    }

    public double parse(String value, double defValue) {
        try {
            return decimalFormat.parse(value).doubleValue();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return defValue;
    }

    private String removeGroupSeparators(String number) {
        return number.replace(String.valueOf(groupSeparator), "");
    }

}

Имейте в виду, что String.format () и DecimalFormat создают строку с использованием локали по умолчанию. Таким образом, они могут записывать форматированные числа с точкой или запятой в качестве разделителя между целыми и десятичными частями. Чтобы убедиться, что округленная строка имеет формат, который вы хотите, используйте java.text.NumberFormat следующим образом:

  Locale locale = Locale.ENGLISH;
  NumberFormat nf = NumberFormat.getNumberInstance(locale);
  // for trailing zeros:
  nf.setMinimumFractionDigits(2);
  // round to 2 digits:
  nf.setMaximumFractionDigits(2);

  System.out.println(nf.format(.99));
  System.out.println(nf.format(123.567));
  System.out.println(nf.format(123.0));

Будет печататься на английском языке (независимо от вашего региона): 0,99 123,57 123.00

Пример взят из Фаренды - как правильно преобразовать double в String.

Если считать 5 или n десятичным числом. Может быть, этот ответ решит вашу проблему.

    double a = 123.00449;
    double roundOff1 = Math.round(a*10000)/10000.00;
    double roundOff2 = Math.round(roundOff1*1000)/1000.00;
    double roundOff = Math.round(roundOff2*100)/100.00;

    System.out.println("result:"+roundOff);

Результат будет: 123.01
это можно решить с помощью цикла и рекурсивной функции.

DecimalFormat - лучший способ вывода, но я не предпочитаю его. Я всегда делаю это все время, потому что он возвращает двойное значение. Так что я могу использовать его не только для вывода.

Math.round(selfEvaluate*100000d.0)/100000d.0;

ИЛИ ЖЕ

Math.round(selfEvaluate*100000d.0)*0.00000d1;

Если вам нужно значение с большими десятичными знаками, вы можете вместо этого использовать BigDecimal. В любом случае .0 важен. Без него округление 0,33333d5 вернет 0,33333 и только 9 цифр допустимы. Вторая функция без .0 имеет проблемы с 0.30000 return 0.30000000000000004.

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

Как округлить число на Java

Чаще всего используется Math.round().

Math.round(3.7) // 4

Числа округляются до ближайшего целого числа. Значение .5 округляется в большую сторону. Если вам нужно другое поведение округления, чем это, вы можете использовать одну из других функций Математика. См. Сравнение ниже.

круглый

Как указано выше, выполняется округление до ближайшего целого числа. Десятичные числа .5 округляются в большую сторону. Этот метод возвращает int.

Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4

Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4

потолок

Любое десятичное значение округляется до следующего целого числа. Он переходит в потолокing. Этот метод возвращает double.

Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0

Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0

этаж

Любое десятичное значение округляется до следующего целого числа. Этот метод возвращает double.

Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0

Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0

полоска

Это похоже на округление десятичных значений до ближайшего целого числа. Однако, в отличие от round, значения .5 округляются до четного целого числа. Этот метод возвращает double.

Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***

Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***

Краткое решение:

   public static double round(double value, int precision) {
      int scale = (int) Math.pow(10, precision);
      return (double) Math.round(value * scale) / scale;
  }

См. Также https://stackoverflow.com/a/22186845/212950 Спасибо jpdymond за это.

Если вы используете технологию с минимальным JDK. Вот способ без каких-либо библиотек Java:

double scale = 100000;    
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;

Вот лучшая функция, которая правильно округляет крайние случаи, такие как 1.005.

Просто мы добавляем наименьшее возможное значение с плавающей запятой (= 1 ulp; единица в последнем месте) к числу перед округлением. Это переходит к следующему представимому значению после числа, отличному от нуля.

Это небольшая программа для проверки: ideone.com

/**
 * Round half away from zero ('commercial' rounding)
 * Uses correction to offset floating-point inaccuracies.
 * Works symmetrically for positive and negative numbers.
 */
public static double round(double num, int digits) {

    // epsilon correction
    double n = Double.longBitsToDouble(Double.doubleToLongBits(num) + 1);
    double p = Math.pow(10, digits);
    return Math.round(n * p) / p;
}

// test rounding of half
System.out.println(round(0.5, 0));   // 1
System.out.println(round(-0.5, 0));  // -1

// testing edge cases
System.out.println(round(1.005, 2));   // 1.01
System.out.println(round(2.175, 2));   // 2.18
System.out.println(round(5.015, 2));   // 5.02

System.out.println(round(-1.005, 2));  // -1.01
System.out.println(round(-2.175, 2));  // -2.18
System.out.println(round(-5.015, 2));  // -5.02

Для этого мы можем использовать это средство форматирования:

 DecimalFormat df = new DecimalFormat("#.00");
 String resultado = df.format(valor)

или же:

DecimalFormat df = new DecimalFormat("0.00"); :

Используйте этот метод, чтобы всегда получать два десятичных знака:

   private static String getTwoDecimals(double value){
      DecimalFormat df = new DecimalFormat("0.00"); 
      return df.format(value);
    }

Определение этих значений:

91.32
5.22
11.5
1.2
2.6

Используя этот метод, мы можем получить следующие результаты:

91.32
5.22
11.50
1.20
2.60

демо онлайн.

вот мой ответ:

double num = 4.898979485566356;
DecimalFormat df = new DecimalFormat("#.##");      
time = Double.valueOf(df.format(num));

System.out.println(num); // 4.89

Итак, после прочтения большинства ответов я понял, что большинство из них не будут точными, на самом деле использование BigDecimal кажется лучшим выбором, но если вы не понимаете, как работает RoundingMode, вы неизбежно потеряете точность. Я понял это, работая с большими числами в проекте, и подумал, что это может помочь другим, у которых возникают проблемы с округлением чисел. Например.

BigDecimal bd = new BigDecimal("1363.2749");
bd = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println(bd.doubleValue());

Вы ожидаете получить 1363.28 на выходе, но в конечном итоге получите 1363.27, чего не ожидается, если вы не знаете, что делает RoundingMode. Заглянув в Документы Oracle, вы найдете следующее описание RoundingMode.HALF_UP.

Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.

Итак, зная это, мы поняли, что не получим точного округления, если только не захотим округлить до ближайший сосед. Итак, чтобы выполнить адекватный раунд, нам нужно будет перейти от десятичной дроби n-1 к желаемым десятичным цифрам. Например.

private double round(double value, int places) throws IllegalArgumentException {

    if (places < 0) throw new IllegalArgumentException();

    // Cast the number to a String and then separate the decimals.
    String stringValue = Double.toString(value);
    String decimals = stringValue.split("\.")[1];

    // Round all the way to the desired number.
    BigDecimal bd = new BigDecimal(stringValue);
    for (int i = decimals.length()-1; i >= places; i--) {
        bd = bd.setScale(i, RoundingMode.HALF_UP);
    }

    return bd.doubleValue();
}

Это даст нам ожидаемый результат, которым будет 1363.28.

Я использовал ниже, как в java 8. Он работает для меня.

    double amount = 1000.431;        
    NumberFormat formatter = new DecimalFormat("##.00");
    String output = formatter.format(amount);
    System.out.println("output = " + output);

Выход:

output = 1000.43

При необходимости можно использовать следующий метод double

double getRandom(int decimalPoints) {
    double a = Math.random();
    int multiplier = (int) Math.pow(10, decimalPoints);
    int b = (int) (a * multiplier);
    return b / (double) multiplier;
}

например getRandom(2)

1. Чтобы иметь завершающие нули до 5-й позиции

DecimalFormat decimalFormatter = new DecimalFormat("#.00000");
decimalFormatter.format(0.350500); // result 0.350500

2. Чтобы не тянуть нули до 5-й позиции

DecimalFormat decimalFormatter= new DecimalFormat("#.#####");
decimalFormatter.format(0.350500); // result o.3505

Простой способ сравнения, если количество десятичных знаков ограничено. Вместо DecimalFormat, Math или BigDecimal мы можем использовать Casting!

Вот образец,

public static boolean threeDecimalPlaces(double value1, double value2){
    boolean isEqual = false;
    // value1 = 3.1756 
    // value2 = 3.17
    //(int) (value1 * 1000) = 3175
    //(int) (value2 * 1000) = 3170

    if ((int) (value1 * 1000) == (int) (value2 * 1000)){
        areEqual = true;
    }

    return isEqual;
}

public static double formatDecimal(double amount) {
    BigDecimal amt = new BigDecimal(amount);
    amt = amt.divide(new BigDecimal(1), 2, BigDecimal.ROUND_HALF_EVEN);
    return amt.doubleValue();
}

Тест с использованием Junit

@RunWith(Parameterized.class)
public class DecimalValueParameterizedTest {

  @Parameterized.Parameter
  public double amount;

  @Parameterized.Parameter(1)
  public double expectedValue;

@Parameterized.Parameters
public static List<Object[]> dataSets() {
    return Arrays.asList(new Object[][]{
            {1000.0, 1000.0},
            {1000, 1000.0},
            {1000.00000, 1000.0},
            {1000.01, 1000.01},
            {1000.1, 1000.10},
            {1000.001, 1000.0},
            {1000.005, 1000.0},
            {1000.007, 1000.01},
            {1000.999, 1001.0},
            {1000.111, 1000.11}
    });
}

@Test
public void testDecimalFormat() {
    Assert.assertEquals(expectedValue, formatDecimal(amount), 0.00);
}