Как округлить число до n знаков после запятой в Java
То, что я хотел бы, - это метод преобразования двойного числа в строку, которая округляется с использованием метода половинного увеличения - то есть, если десятичное число округляется до 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?
39 ответов
Использование 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
Если предположить, value это double, ты можешь сделать:
(double)Math.round(value * 100000d) / 100000d
Это для точности 5 цифр. Количество нулей указывает количество десятичных знаков.
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));
}
Вы также можете использовать
DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);
чтобы убедиться, что у вас есть конечные 0.
Как отметили некоторые другие, правильный ответ - использовать либо DecimalFormat или же BigDecimal, Плавающая точка не имеет десятичных разрядов, поэтому вы не можете округлять / усекать их до определенного числа. Вы должны работать с десятичным основанием, и это то, что делают эти два класса.
Я публикую следующий код в качестве контрпримера ко всем ответам в этой теме и даже по всему Stackru (и в других местах), которые рекомендуют умножение с последующим усечением с последующим делением. Сторонники этого метода обязаны объяснить, почему следующий код дает неправильный вывод в более чем 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: вы получаете два преимущества по цене реализации одного кода.;)
Вот краткое изложение того, что вы можете использовать, если хотите получить результат в виде строки:
DecimalFormat # setRoundingMode ():
DecimalFormat df = new DecimalFormat("#.#####"); df.setRoundingMode(RoundingMode.HALF_UP); String str1 = df.format(0.912385)); // 0.91239String str2 = new BigDecimal(0.912385) .setScale(5, BigDecimal.ROUND_HALF_UP) .toString();
Вот предложение о том, какие библиотеки вы можете использовать, если хотите double в следствии. Я бы не рекомендовал это для преобразования строк, так как double может быть не в состоянии точно представить, что вы хотите (см., Например, здесь):
Краткое решение:
public static double round(double value, int precision) {
int scale = (int) Math.pow(10, precision);
return (double) Math.round(value * scale) / scale;
}
См. Также /questions/28556470/ispolzovanie-mathround-dlya-okrugleniya-do-odnogo-znaka-posle-zapyatoj/28556488#28556488 Спасибо jpdymond за это.
Вы можете использовать следующий метод утилиты:
public static double round(double valueToRound, int numberOfDecimalPlaces)
{
double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
double interestedInZeroDPs = valueToRound * multipicationFactor;
return Math.round(interestedInZeroDPs) / multipicationFactor;
}
Вы можете использовать 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 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.
Use BigDecimal or any other decimal-based format.
Я использую BigDecimal для расчетов, но имейте в виду, что это зависит от размера чисел, с которыми вы имеете дело. В большинстве моих реализаций я считаю, что синтаксический анализ от двойного или целого до длинного вполне достаточен для очень большого числа вычислений.
На самом деле, я недавно использовал parsed-to-Long для получения точных представлений (в отличие от шестнадцатеричных результатов) в графическом интерфейсе для чисел, таких как ################## ############### символы (как пример).
Так как я не нашел полного ответа на эту тему, я собрал класс, который должен обрабатывать это правильно, с поддержкой:
- Форматирование: легко форматировать двойные строки с определенным количеством десятичных знаков
- Синтаксический анализ: разобрать форматированное значение обратно, чтобы удвоить
- Язык: форматировать и анализировать, используя язык по умолчанию
- Экспоненциальная запись: начните использовать экспоненциальную запись после определенного порога
Использование довольно просто:
(Ради этого примера я использую пользовательскую локаль)
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), "");
}
}
Попробуйте это: 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;
}
}
}
На всякий случай, если кому-то все еще нужна помощь с этим. Это решение отлично работает для меня.
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.
Я пришел сюда просто, чтобы получить простой ответ о том, как округлить число. Это дополнительный ответ, чтобы обеспечить это.
Как округлить число в 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 ***
Итак, после прочтения большинства ответов я понял, что большинство из них не будут точными, на самом деле используя 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 Docs, вы найдете следующее описание дляRoundingMode.HALF_UP.
Режим округления для округления в сторону "ближайшего соседа", если оба соседа не равноудалены, в этом случае округление в большую сторону.
Итак, зная это, мы поняли, что не получим точного округления, если только не захотим округлить в сторону ближайшего соседа. Итак, чтобы выполнить адекватный раунд, нам потребуется цикл отn-1decimal к желаемым десятичным разрядам. Например.
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.
Вот мой ответ:
double num = 4.898979485566356;
DecimalFormat df = new DecimalFormat("#.##");
time = Double.valueOf(df.format(num));
System.out.println(num); // 4.89
Если вы используете DecimalFormat преобразовать double в StringЭто очень просто:
DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);
double num = 1.234567;
return formatter.format(num);
Есть несколько RoundingMode enum значения на выбор, в зависимости от поведения, которое вам требуется.
Если вы используете технологию, которая имеет минимальный JDK. Вот способ без каких-либо библиотек Java:
double scale = 100000;
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;
В общем, округление выполняется путем масштабирования: 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
Фрагмент кода ниже показывает, как отображать 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 - лучший способ вывода, но я не предпочитаю его. Я всегда делаю это все время, потому что он возвращает двойное значение. Так что я могу использовать это больше, чем просто вывод.
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.
Я использовал ниже, как в java 8. он работает для меня
double amount = 1000.431;
NumberFormat formatter = new DecimalFormat("##.00");
String output = formatter.format(amount);
System.out.println("output = " + output);
Выход:
output = 1000.43
- Чтобы иметь завершающие нули до 5-й позиции
DecimalFormat decimalFormatter = new DecimalFormat("#.00000"); decimalFormatter.format(0.350500); // result 0.350500
- Чтобы не тянуться к 5-й позиции
DecimalFormat decimalFormatter= new DecimalFormat("#.#####"); decimalFormatter.format(0.350500); // result o.3505