Double — Округление в java


12.12. Java — Метод Math.round()

Содержание

Описание

Метод Math.round() — возвращает целое число, long или int, ближайшее к вещественному числу, double или float, аргумента. Иными словами — округляет дробь до целого числа.

Синтаксис

Метод имеет следующие варианты округления до целого числа:

Параметры

Подробная информация о параметрах:

  • d — double или float примитивный тип данных.
  • f — тип данных float.

Двойное значение для округления в Java

У меня двойное значение = 1.068879335 я хочу, чтобы округлить его только с двумя десятичными значениями, как 1,07.

это дает мне следующее исключение

может кто-нибудь сказать мне, что не так с моим кодом.

наконец, мне нужно finalValue = 1.07;

9 ответов

Запишите запятую в вашей строке: «1,07». DecimalFormat использует специфическую для локали строку-разделитель, в то время как Double.parseDouble() не. Так как вы живете в стране, где десятичный разделитель равен «,», вы не можете разобрать свой номер обратно.

Тем не менее, вы можете использовать тот же DecimalFormat разобрать его обратно:

Но вы действительно должны сделать это вместо этого:

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

Live @ решение Сергея, но с целочисленным делением.

РЕДАКТИРОВАТЬ: Как указывает Сергей, не должно быть никакой разницы между умножением double * int и double * double и делением double / int и double / double. Я не могу найти пример, где результат отличается. Однако в x86/x64 и других системах есть специальная инструкция машинного кода для смешанных значений типа double,int, которые, как мне кажется, использует JVM.

Проблема заключается в том, что вы используете локализующий форматер, который генерирует десятичную точку для конкретной локали, которая в вашем случае равна «,». Но Double.parseDouble() ожидает нелокализованный двойной литерал. Вы можете решить свою проблему, используя метод синтаксического анализа для конкретной локали или изменив локаль вашего форматера на что-то, использующее «.» в качестве десятичной точки. Или, что еще лучше, избегайте ненужного форматирования, используя что-то вроде этого:


В том, что вы пытаетесь сделать, что-то в корне не так. Двоичные значения с плавающей запятой не имеют десятичных разрядов. Вы не можете осмысленно округлить от одного до заданного количества десятичных знаков, потому что большинство «округлых» десятичных значений просто не могут быть представлены в виде двоичной дроби. Вот почему никогда не следует использовать float или же double представлять деньги.

Так что если вы хотите, чтобы в вашем результате были десятичные знаки, этот результат должен быть либо String (который вы уже получили с DecimalFormat ) или BigDecimal (который имеет setScale() метод, который делает именно то, что вы хотите). В противном случае результат не может быть таким, каким вы хотите его видеть.

Прочитайте Руководство с плавающей точкой для получения дополнительной информации.

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

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

Вы можете попытаться определить новый DecimalFormat и использовать его как результат Double для новой двойной переменной.

Пример приведен, чтобы вы поняли, что я только что сказал.

Округление чисел double

31.07.2012, 02:35

Примерное округление double
Всем Доброго Дня! Подскажите пожалуйста цифру, чтобы число округлялось до 4 или даже лучше 5.

Округление double в меньшую сторну
Всем привет! Сразу прошу палками не бить, так как полный новичок в Java :) Подскажите люди.

Округление чисел
Здравствуйте! У меня вот такой вопрос, Как можно сделать чтоб выводило на экран косинусы углов 45 и.

Округление чисел в JAVA
Как можно округлить значения? riskPassport.setTargetVal(entity.getTargetVal() !=.

Формат чисел double
Всем привет. Решил протабулировать функцию.. вот какой получился вывод У меня вопрос такой.

Округление номера в Java

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

В настоящее время у меня есть моя программа для округления до целого числа с помощью double rACT = Math.ceil(ACT); double rSAT = Math.ceil(SAT); double rGPA = Math.ceil(GPA);

но мне нужно округлить до двух знаков после запятой

FYI — Я ученик средней школы. Мне действительно не нужно что-то супер сложное для этого, потому что мне нужно, чтобы мои методы были меньше 15. Я могу тратить любые строки

java double rounding

4 ответа

Вероятно, есть более простой способ, но очевидным является:


Это превращает число, подобное 2.123, в 212.3, округляет его до 213, а затем делит обратно на 2.13.

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

Этот код округляется до двух десятичных знаков максимум и использует потолок.

Андроид, финты ушами.

Мыши плакали, кололись, но продолжали грызть кактус.

четверг, 3 апреля 2014 г.

Округление чисел в Java

При выводе результатов числовых расчётов часто бывает ситуация, когда вместо десятичной дроби, например, 3,7, отображается число 3,6999999999999997. Это происходит из-за того, что далеко не все десятичные дроби можно точно представить в двоичном коде. В случае невозможности записать десятичную дробь точно, используется самое близкое к ней значение, которое можно выразить двоичным числом. При обратном переводе в десятичный формат это значение и даёт такие непонятные длинные дроби.

Перевод десятичных дробей в двоичную систему счисления

Невозможность записать некоторые десятичные дроби в двоичной системе (нулями и единицами) можно привести на примере обычного небольшого десятичного числа 20.1. Целая часть десятичных дробей переводится в двоичный вид точно так же, как целые числа, то есть складыванием положительных степеней двойки так, чтобы в итоге получить искомую сумму:

Получаем, что 2010 = 000101002

Как мы видим по таблице, справа налево вес каждого разряда двоичного числа увеличивается вдвое (положительные степени двойки). Набираем число 20, суммируя результаты этих степеней и отмечая единичками те степени, которые мы использовали. Вариант у нас только один – использовать степени 2 и 4, то есть числа 4 и 16, в сумме как раз дающие 20. Отметив их единичками, получаем двоичное число 00010100 или, если отбросить незначащие нули, 10100.

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

Цукерберг рекомендует:  Ios - Поиск новичков в ios-dev

Эту таблицу мы можем продолжать вправо до бесконечности, но никогда не наберём полные 0.1. В итоге получаем, что 0,110 ≈ 00011001100112 = 0,099975585937510.

Таким образом, 20,110 ≈ 10100,00011001100112.

Хранение чисел с плавающей точкой в компьютере

В компьютере числа двойной точности (в Java тип Double) хранятся в экспоненциальном (т.н. научном, инженерном) формате. Этот формат, например, записывает десятичное число 20,1 как 2,01*10 1 , или сокращённо, как 2,01E+1. То есть, число после буквы E указывает, на сколько знаков следует сдвинуть запятую вправо (или влево, если число отрицательное) в числе, стоящем перед буквой

Переведённое в двоичную систему число 20,1, выглядящее как 10100,0001100110011 в экспоненциальной форме будет выглядеть как 1,01000001100110011 * 2 100 , или сокращённо 1,01000001100110011E+100 (двоичное 100 — это десятичное 4, то есть сдвигать запятую в числе 1,01000001100110011 следует на 4 знака вправо).

Для хранения этих чисел в компьютере отводится 64 бита (8 байт). Биты распределяются следующим образом. Для знака числа (плюс или минус) отводится 1 бит, для записи порядка (в нашем случае 100) — 11 бит, а для записи мантиссы (в нашем случае 1,01000001100110011) — 52 бита.

Схематично это выглядит так:

Чтобы иметь возможность записывать отрицательные порядки, за ноль в поле порядка принято число 1023 (в двоичном коде — 01111111111), что делит весь возможный диапазон порядков примерно пополам (от -1023 до 0 и от 0 до 1024). Поэтому наш порядок 100 фактически выглядит в битах, как 10000000011, ведь 1023 + 4 = 1027.

Кроме того, по причинам экономии на аппаратных ресурсах, самого левого бита мантиссы «в железе» не существует, но программно он всегда подразумевается. Этот бит принимается равным 1 во всех случаях, кроме случая нахождения в поле порядка специального числа -1023 (значения битов 00000000000). В нашем случае в поле порядка занесено число 4, а значит, левый бит признаётся единичным, и поэтому у нас в мантиссе фактически лежит лишь дробная часть, то есть число 01000001100110011.


Исходя из вышесказанного, для нашего числа 10100,0001100110011 значения всех 64 реальных битов и 1 подразумеваемого таковы:

Несколько слов про магическое число -1023 (значение битов 00000000000) в поле порядка. Как я уже говорил, это число просто устанавливает подразумеваемый бит целой части мантиссы в ноль. Если все остальные биты мантиссы также будут нулевыми, то хранимое таким образом в компьютере число, очевидно, будет являться нулём.

В случае же наличия в мантиссе ненулевых битов при том же числе -1023 в поле порядка, подразумеваемый бит целой части мантиссы также принимается равным нулю, но значение порядка подразумевается равным -1022. Грубо говоря, смена чисел в поле порядка с -1022 на -1023 и обратно влияют только на снятие или установку единичного бита целой части мантиссы, тогда как и то, и другое значение порядка подразумевается равным -1022.

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

Это легко понять, представив, как восстанавливается число из экспоненциального формата. Основание системы счисления (2) возводится в степень порядка и умножается на мантиссу. Самое маленькое число типа Double, которое мы можем так выразить, равно 1 * 2 -1022 . Ведь подразумеваемый бит равен единице, а значит, мантисса не может быть меньше единицы. Постепенно увеличивая мантиссу с 1 до почти 2 мы можем равномерно заполнить числами весь диапазон до предыдущего порядка 1 * 2 -1021 . Но у нас всегда остаётся незаполненный диапазон с другой стороны — в сторону нуля. И вот его то мы можем целиком заполнить только делая мантиссу меньше единицы. А для этого надо просто переключить подразумеваемый бит в ноль, что мы и делаем!

Существует ещё одно магическое число в поле порядка — 1024 (значение битов 11111111111). В зависимости от содержимого мантиссы, оно означает либо бесконечность (1 / 0 = ∞) либо неопределённость (неупорядоченное число, не число) (0 / 0 = NaN). Если мантисса нулевая — перед нами бесконечность, иначе — неопределённость.

Правильное округление в Java

Конечно, в Java есть функции, которые умеют округлять числа до нужного знака после запятой. Но иногда может встретится число, которое в десятичном виде округляется в большую сторону, а будучи записано в двоичном виде становится чуть меньше, и уже по правилам должно округляться в меньшую сторону. В качестве примера такого числа можно привести число 13,5465. Очевидно, что оно должно округляться в большую сторону до 13,547. Но при записи в двоичный код число становится равным 13,5464999…, и оно уже должно округляться в меньшую сторону до 13,546.

Но ведь мы мыслим и думаем в десятичной системе счисления, а значит, хотим видеть числа, всегда округлённые в правильную сторону вне зависимости от того, как они там внутри компьютера выглядят. Чтобы провести такое округление и отобразить число правильно, мы должны написать на Java небольшой код:

Теперь мы можем применить этот метод, например, если программируем под Андроид, при выводе результата result в поле EditText активности:

Рассмотрим, как же это работает. Метод roundUp принимает подлежащее округлению число value типа double и желаемое количество знаков после запятой digits типа int. Возвращает метод результат в виде числа типа BigDecimal. Тип BigDecimal хранит данные не в виде двоичного представления числа с плавающей запятой, о котором я рассказывал выше, а в виде числа с фиксированной запятой. Число с фиксированной запятой содержит в себе два отдельных целых числа. Это исходное число, но без запятой, и число, содержащее количество знаков после запятой. А целые числа всегда можно записать в двоичный формат абсолютно точно. Так что на выходе мы потенциально можем получить любую точную десятичную дробь.

Внутри нашего метода создаётся объект BigDecimal, который принимает на вход число с плавающей запятой value типа double, и методом setScale округляет его. Но при обычном использовании этого метода число округляется всё по тем же правилам, что приводит к неправильному округлению. В нашем же методе есть одна хитрость. Чтобы округление всегда происходило в нужную сторону, значение на вход метода BigDecimal мы передаём не в виде числа, а в виде строки. На этапе преобразования числа в строку, язык Java сам автоматически округляет число с достаточным количеством знаков, до степени, имеющей смысл (округляя весь хвост, начинающийся с последовательности девяток или нулей, подозревая в этом погрешность). Таким образом, мы подаём на вход BigDecimal строку с уже исправленной погрешностью.

Цукерберг рекомендует:  С Дня карьеры в «Альфа-Банк» история студента GU

Чтобы перевести число в строку, мы использовали трюк «»+value. При сложении числа со строкой (даже пустой) результат окажется тоже строкой.

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

Результат: 13,546 — неправильно!

Результат: 13,547 — правильно.

Вообще, такую удобную особенность преобразования double в строку, как исправление погрешности, можно объяснить тем, что строки обычно используются только для отображения информации, и не участвуют в расчётах, не влияют на них. Поэтому не будет большого криминала даже если погрешность будет исправлена ошибочно. Всё равно такая внезапно округлённая строка при правильной архитектуре приложения не будет участвовать в дальнейших расчётах, но покажет пользователю очень близкий к истинному результат, к тому же более удобный для восприятия.

Если нам нужно вести расчёты вообще без погрешностей, возникающих из-за двоичного представления чисел, то вместо переменных типа Double следует сразу использовать тип BigDecimal, и все расчёты производить с использованием методов этого типа. Обычно такие расчёты используют в бухгалтерии, где при любых суммах для правильной отчётности важна точность до копейки. В других же случаях такой неестественной точности, как правило, не требуется, поскольку погрешность двоичного представления теряется на фоне погрешностей, уже существующих во входных данных из внешнего мира.

Двойное значение для округления в Java

У меня двойное значение = 1.068879335 я хочу, чтобы округлить его только с двумя десятичными значениями, как 1,07.

это дает мне следующее исключение

может кто-нибудь сказать мне, что не так с моим кодом.


наконец, мне нужно finalValue = 1.07;

9 ответов

Запишите запятую в вашей строке: «1,07». DecimalFormat использует специфическую для локали строку-разделитель, в то время как Double.parseDouble() не. Так как вы живете в стране, где десятичный разделитель равен «,», вы не можете разобрать свой номер обратно.

Тем не менее, вы можете использовать тот же DecimalFormat разобрать его обратно:

Но вы действительно должны сделать это вместо этого:

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

Live @ решение Сергея, но с целочисленным делением.

РЕДАКТИРОВАТЬ: Как указывает Сергей, не должно быть никакой разницы между умножением double * int и double * double и делением double / int и double / double. Я не могу найти пример, где результат отличается. Однако в x86/x64 и других системах есть специальная инструкция машинного кода для смешанных значений типа double,int, которые, как мне кажется, использует JVM.

Проблема заключается в том, что вы используете локализующий форматер, который генерирует десятичную точку для конкретной локали, которая в вашем случае равна «,». Но Double.parseDouble() ожидает нелокализованный двойной литерал. Вы можете решить свою проблему, используя метод синтаксического анализа для конкретной локали или изменив локаль вашего форматера на что-то, использующее «.» в качестве десятичной точки. Или, что еще лучше, избегайте ненужного форматирования, используя что-то вроде этого:

В том, что вы пытаетесь сделать, что-то в корне не так. Двоичные значения с плавающей запятой не имеют десятичных разрядов. Вы не можете осмысленно округлить от одного до заданного количества десятичных знаков, потому что большинство «округлых» десятичных значений просто не могут быть представлены в виде двоичной дроби. Вот почему никогда не следует использовать float или же double представлять деньги.

Так что если вы хотите, чтобы в вашем результате были десятичные знаки, этот результат должен быть либо String (который вы уже получили с DecimalFormat ) или BigDecimal (который имеет setScale() метод, который делает именно то, что вы хотите). В противном случае результат не может быть таким, каким вы хотите его видеть.

Прочитайте Руководство с плавающей точкой для получения дополнительной информации.

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

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

Вы можете попытаться определить новый DecimalFormat и использовать его как результат Double для новой двойной переменной.

Пример приведен, чтобы вы поняли, что я только что сказал.

Double — Округление в java

169456 просмотра

10 ответа

3015 Репутация автора

У меня есть двойное значение = 1.068879335 я хочу округлить его только с двумя десятичными значениями, как 1,07.

это дает мне следующее исключение


может кто-нибудь сказать мне, что не так с моим кодом.

наконец, мне нужно finalValue = 1.07;

Ответы (10)

1 плюс

80 Репутация автора

Вы можете попытаться определить новый DecimalFormat и использовать его как результат Double для новой двойной переменной.

Пример приведен, чтобы вы поняли, что я только что сказал.

Автор: Markku Размещён: 25.01.2011 05:30

76 плюса

41756 Репутация автора

Запишите запятую в вашей строке: «1,07». DecimalFormat использует специфическую для локали строку-разделитель, в то время Double.parseDouble() как нет. Так как вы живете в стране, где десятичный разделитель равен «,», вы не можете разобрать свой номер обратно.

Тем не менее, вы можете использовать то же самое DecimalFormat для анализа:

Но вы действительно должны сделать это вместо этого:

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

1 плюс

9161 Репутация автора

Это невозможно в запрошенном виде, поскольку существуют числа с двумя десятичными разрядами, которые не могут быть точно выражены с помощью чисел с плавающей запятой IEEE (например, 1/10 = 0,1 не может быть выражено как Double или Float ). Форматирование всегда должно выполняться как последний шаг перед тем, как представить результат пользователю.

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

6 плюса

18399 Репутация автора

Проблема заключается в том, что вы используете локализующий форматер, который генерирует десятичную точку для конкретной локали, которая в вашем случае равна «,». Но Double.parseDouble () ожидает нелокализованный двойной литерал. Вы можете решить вашу проблему, используя метод синтаксического анализа для конкретной локали или изменив локаль вашего форматера на что-то, что использует «.» в качестве десятичной точки. Или, что еще лучше, избегайте ненужного форматирования, используя что-то вроде этого:

4 плюса


297954 Репутация автора

В том, что вы пытаетесь сделать, что-то в корне не так. Двоичные значения с плавающей запятой не имеют десятичных разрядов. Вы не можете осмысленно округлить от одного до заданного числа десятичных знаков, потому что большинство «округлых» десятичных значений просто не могут быть представлены в виде двоичной дроби. Вот почему никогда не следует использовать float или double представлять деньги.

Цукерберг рекомендует:  Просто отдайте первенца и дело с концом

Поэтому, если вы хотите, чтобы в вашем результате были десятичные разряды, этот результат должен быть либо String (который вы уже получили с DecimalFormat ), либо BigDecimal (который имеет setScale() метод, который делает именно то, что вы хотите). В противном случае результат не может быть таким, каким вы хотите его видеть.

Прочитайте Руководство с плавающей точкой для получения дополнительной информации.

18 плюса

449090 Репутация автора

Live @ решение Сергея, но с целочисленным делением.

РЕДАКТИРОВАТЬ: Как указывает Сергей, не должно быть никакой разницы между умножением double * int и double * double и делением double / int и double / double. Я не могу найти пример, где результат отличается. Однако в x86 / x64 и других системах есть специальная инструкция машинного кода для смешанных значений типа double, int, которые, как я полагаю, использует JVM.

1 плюс

5423 Репутация автора

плюса

526 Репутация автора

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

2 плюса

1270 Репутация автора

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

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

Автор: Li Ying Размещён: 20.02.2014 05:00

плюса

140 Репутация автора

Если вы не хотите использовать DecimalFormat (например, из-за его эффективности) и хотите общее решение, вы также можете попробовать этот метод, который использует масштабированное округление:

«Практическое» двойное округление в Java


Итак, я много читал об этом, поэтому, пожалуйста, знайте, что я получаю, что число, подобное 0,6, не может быть представлено абсолютно точно, как Java double, но я знаю, что есть версия двойника, которая представляет число 0,6, достаточно близко, чтобы число отображалось как 0,6 вместо примерно 0,6000000000000001 в большинстве интерпретаций конца этого номера (например, включая toString() или маршалинг JSON с использованием библиотеки, такой как Jackson — моя цель).

Я ищу механизм принуждения двойника к числу, которое интерпретируется как относительная усеченная точность. Например, если я хочу, чтобы укоротить до 0,1 точности, я хочу что-то, что будет представлять 0.6975265613 укороченный до 0,1 точности в 0,6, а не 0,6000000000000001

Таким образом, в основном делает следующую тестовую работу:

Я m, используя longValue() для усечения для скорости, но вы получите тот же результат с Math.floor().

Глядя на сырых значений двойных шестигранных, то cleanValue выше: 3fe3333333333333

В то время как результат округления (значение) является: 3fe3333333333334

Мне нужен метод, который будет последовательно дать мне (первая), независимо от точности округления — при условии, что точность не преследует предел точности для типа. Преобразование в String или BigDecimal будет слишком медленным — это аналитическое приложение, где стоимость этих методов x10 будет очень измеримой.

Опять же, понял, что ни шестнадцатеричное число действительно представляет фактическое число 0,6, я просто хочу Java думать, что это 0,6 (т.е. 3fe3333333333333) :)

Создан 29 май. 15 2015-05-29 02:37:08 tsquared

Мне нужно округлить float до двух десятичных знаков в Java

Возможный дубликат:
Как округлить число до n десятичных знаков в Java

У меня возникают трудности с округлением поплавка до двух знаков после запятой. Я попробовал несколько методов, которые я видел здесь, включая просто использование Math.round() , но независимо от того, что я делаю, я получаю необычные числа.

У меня есть список поплавков, которые я обрабатываю, первый в списке отображается как 1.2975118E7 . Что такое E7 ?

Когда я использую Math.round(f) (f – float), я получаю то же самое число.

Я знаю, что я делаю что-то неправильно, я просто не знаю, что.

Я просто хочу, чтобы числа были в формате x.xx Первое число должно составлять 1.30 и т. Д.

1.2975118E7 – это научная нотация .

Кроме того, Math.round(f) возвращает целое число. Вы не можете использовать его для получения желаемого формата x.xx

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

Если вы ищете форматирование валюты (которое вы не указали, но, похоже, это то, что вы ищете) попробуйте класс NumberFormat . Это очень просто:

Которая будет выводиться (в зависимости от локали):

Кроме того, если валюта не требуется (только точные два десятичных знака), вы можете использовать это вместо:


Который выйдет 2.30

Вы можете использовать DecimalFormat чтобы дать вам стиль, который вы хотите.

Поскольку это в научной нотации, вы не сможете получить число меньше 10 7, не теряя при этом много порядков точности.

Попробуйте взглянуть на класс BigDecimal . Это переход к классу для валюты и поддержка точного округления.

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

Это то, что я сделал, чтобы обогнуть двойник 2 знаков после запятой:

Это прекрасно работает, если сумма = 25,3569 или что-то подобное, но если сумма = 25,00 или сумма = 25,0, то я получаю 25.0! То, что я хочу, и округление, а также форматирование до 2 знаков после запятой.

Просто используйте: (легко, как пирог)

Выход будет 651,52

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

Используйте BigDecimal . Это обсуждалось достаточно широко. Вы должны иметь Money класс и количество должно быть BigDecimal .

Даже если вы не работаете с деньгами, рассмотрим BigDecimal .

Используйте держатель разряд место ( 0 ), как и с « # » отставая / ведущие нули показывают , как отсутствуют:

Вы не можете «круглый двойным [любое количество] знаков после запятой», потому что двойники не имеют знаков после запятой. Вы можете преобразовать двойную к основанию 10 строке с N знаков после запятой, так как база-10 действительно имеет знак после запятой, но когда вы преобразовать его обратно вы вернулись в двойной земле, с бинарными дробными местами.

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

String.Format ( «%. 2f», doubleValue) // изменяет 2, согласно вашему требованию.

Вы можете использовать org.apache.commons.math.util.MathUtils от апача Коммон

double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);

Вы можете использовать Apache Commons Math:

двойная сумма = 25.00;

NumberFormat форматировщик = новый DecimalFormat ( «# 0,00»);

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

Ваш класс Деньги могут быть представлены в виде подкласса Лонга или имеющий элемент, представляющий значение денег как родной долго. Тогда при присвоении значения ваших денег конкретизации, вы всегда будете хранить ценности, которые на самом деле реальные деньги и ценности. (Метод с помощью перегруженной ToString своих денег ()) Вы просто выходной ваших денег объекта с соответствующим форматированием. например $ 1,25 во внутреннем представлении денежного объекта 125. Вы представляете деньги как центы, или пенсы или какой-либо минимальная деноминацию в валюте вы уплотнительная с . то форматировать его на выходе. Нет, вы никогда не можете хранить «незаконное» значение денег, как, скажем, $ 1,257.

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих