Как округлить число до n знаков после запятой в Java

Question

То, что я хотел бы, - это метод преобразования double в строку, которая округляется с использованием метода half-up, т. е.если десятичное число, подлежащее округлению, равно 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?

Answer 1

Использование 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

Answer 2

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

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

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

Answer 3

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

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

Answer 4

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

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

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

Answer 5

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

Answer 6

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

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

Answer 7

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

double d = 3.76628729;

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

Answer 8

Практическое руководство Real's Java How-to Публикации это решение, которое также совместимо с версиями до Java 1.6.

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

Answer 9

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

Answer 10

@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

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

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

Answer 11

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

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

Answer 12

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

1. Десятичный формат#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. Функции от Кольта

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

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

   double rounded = Utils.roundDouble(0.912385, 5)
   

Answer 13

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

   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 Благодаря джпдимонд за то, что предложил это.

Answer 14

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

Answer 15

Попробуй это:org.apache.commons.math3.util.Точность.округление (двойное 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;
        }
    }
}

Answer 16

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

Use BigDecimal or any other decimal-based format.

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

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

Answer 17

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

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

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

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

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

}

Answer 18

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

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

}

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

Answer 19

Приведенный ниже фрагмент кода показывает, как отобразить 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();

Answer 20

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

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

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

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

Answer 21

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

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

Наиболее распространенным случаем является использование Math.round().

Math.round(3.7) // 4

Цифры округляются до ближайшего целого числа.A .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 ***

Answer 22

Чтобы добиться этого, мы можем использовать этот форматировщик:

 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

демо-версия онлайн.

Answer 23

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

Answer 24

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

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

Answer 25

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

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

или

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

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

Answer 26

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

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

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

Answer 27

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

Answer 28

Если вы считаете, что 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
это можно решить с помощью цикла и рекурсивной функции.

Answer 29

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