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

Я также хотел бы, чтобы отображались только значащие цифры - то есть не должно быть никаких завершающих нулей.

Я знаю один способ сделать это, чтобы использовать String.formatметод:

String.format("%.5g%n", 0.912385);

возвращает:

0.91239

это здорово, однако всегда отображает числа с 5 десятичными разрядами, даже если они не имеют значения:

String.format("%.5g%n", 0.912300);

возвращает:

0.91230

Другой метод заключается в использовании DecimalFormatter:

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

возвращает:

0.91238

Однако, как вы можете видеть, для этого используется округление до половины. То есть будет округляться, если предыдущая цифра четная. Что я хотел бы это:

0.912385 -> 0.91239
0.912300 -> 0.9123

Каков наилучший способ добиться этого в Java?

Используйте 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

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

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

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

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

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

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

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

получит тебя BigDecimal. Для того, чтобы получить строку из него, просто назвать это BigDecimal«ы toStringметод, или 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));
    }

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

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

чтобы убедиться, что у вас есть конечные 0.

Как отметили некоторые другие, правильный ответ должен использовать либо 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

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

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

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

double d = 3.76628729;

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

Как к Java Real в постах это решение, которое также совместим для версий до Java 1.6.

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

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

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

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

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

чтобы убедиться, что у вас есть конечные 0.

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

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

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: вы получаете два преимущества по цене одной реализации кода. ;)

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

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. Утилиты из Века

   double rounded = Utils.roundDouble(0.912385, 5)

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

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

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

   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 за это.

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

Попробуйте это: org.apache.commons.math3.util.Precision.round (double x, int scale)

См. 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;
        }
    }
}

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

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

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

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

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

}

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

Use BigDecimal or any other decimal-based format.

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

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

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

 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

Демо онлайн.

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

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

}

возвращает String с желаемым выходом.

Я согласен с выбранным ответом использовать 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 .

Фрагмент кода ниже показывает, как отображать 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в String, это очень просто:

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

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

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

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

Как округлить число в 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

перекрывать

Любое десятичное значение округляется до следующего целого числа. Идет к потолку . Этот метод возвращает 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 ***

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

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

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 возвращает 0.30000000000000004.

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

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.

Режим округления для округления до «ближайшего соседа», если оба соседа не равноудалены, в этом случае округление вверх.

Итак, зная это, мы поняли, что не получим точное округление, если не хотим округлить до ближайшего соседа . Таким образом, чтобы выполнить адекватный раунд, нам нужно было бы выполнить цикл от 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.

Где dp = десятичное место, которое вы хотите, а значение является двойным.

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

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

Имейте в виду, что 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

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

В общем, округление выполняется путем масштабирования: round(num / p) * p

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */
double RoundCorrect(double num, int precision) {
    double c = 0.5 * EPSILON * num;
//  double p = Math.pow(10, precision); //slow
    double p = 1; while (precision--> 0) p *= 10;
    if (num < 0)
        p *= -1;
    return Math.round((num + c) * p) / p;
}

// testing edge cases
RoundCorrect(1.005, 2);   // 1.01 correct
RoundCorrect(2.175, 2);   // 2.18 correct
RoundCorrect(5.015, 2);   // 5.02 correct

RoundCorrect(-1.005, 2);  // -1.01 correct
RoundCorrect(-2.175, 2);  // -2.18 correct
RoundCorrect(-5.015, 2);  // -5.02 correct