Kwert-soft.ru

IT Софт для ПК
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Java round округление

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

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

Я также хотел бы, чтобы отображались только значимые цифры — т. е. не должно быть никаких конечных нулей.

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

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

другой метод-использовать DecimalFormatter :

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

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

29 ответов

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

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

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

будет Вам BigDecimal . Чтобы получить строку из него, просто назовите это BigDecimal ‘ s toString метод, или toPlainString метод для Java 5+ для строки простого формата.

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

чтобы убедиться, что у вас есть трейлинг-0 у.

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

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

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

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

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

или без BigDecimal

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

можно использовать класс DecimalFormat.

реальный Java How-to посты это решение, которое также совместимо для версий до Java 1.6.

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

чтобы убедиться, что у вас есть трейлинг-0 у.

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

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

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

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

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

[EDIT: также, если формат каретки такой («#0.############ «) и ты введите десятичное число, например 3.1415926, для аргумента, DecimalFormat не производит никакого мусора (например, трейлинг-нули) и вернется: 3.1415926 .. если вы склонны к этому. Конечно, это немного многословно по вкусу некоторым разработчикам — но эй, у него низкий след памяти во время обработки и очень легко реализовать.]

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

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

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

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

точность из Apache Commons Math

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

попробуйте это: org.апаш.палата общин.math3.утиль.Точность.круглый (двойной X, int масштаб)

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

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

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

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

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

вот класс:

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

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

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

Читать еще:  Java метод append

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

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

если вы используете DecimalFormat преобразование double to String , Это очень просто:

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

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

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

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

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

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

круглые

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

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

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

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

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

читайте обновление ниже первого!

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

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

отказ от ответственности: я участвую в проекте decimal4j.

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

Примечания:

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

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

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

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

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

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

при определении этого значения:

используя метод, мы можем получить такой результат:

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

будет печатать на английском языке (независимо от вашего языка): 0.99 123.57 123.00

здесь dp = десятичное число, которое вы хотите, и стоимостью — это двойной.

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

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

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

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

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

  • написана командой Vertex Academy. Надеемся, что она Вам будет полезна. Приятного прочтения!
  • это одна из статей из нашего «Самоучителя по Java»

В пакете java.lang есть класс Math , а в этом классе есть 3 метода округления чисел с плавающей точкой до ближайшего целого числа:

Названия методов от английских слов:

round — от англ. «округлять»

floor — от англ. «пол»

ceiling — от англ. «потолок»

Давайте рассмотрим на примере как работают эти методы:

Читать еще:  Исправление пунктуационных ошибок в тексте онлайн
Пример №1

Если Вы запустите данный код на своем компьютере, в консоли Вы увидите:

Комментарии:

1. Math.round () данный метод округляет до ближайшего целого числа .

И действительно, на входе было 5.25, а метод нам вернул число 5, поскольку ближайшее целое число — это 5. Если бы, например, мы этим методом округляли число 8.75, то мы бы получили 9, потому что это ближайшее целое число.

Также обратите внимание, что данный метод возвращает значение типа int, то есть целое число. На входе было число 5.25, а метод вернул нам не 5.0, а 5

2. Math.floor ()данный метод округляет число до ближайшего целого вниз.

И действительно, у нас было число 5.25, ближайшее число вниз — это 5.0 А если бы мы, например, округляли с помощью этого метода число 8.75, то получили бы число 8.0, потому что ближайшее целое число вниз — это 8.0.

Теперь Вы понимаете почему метод называется floor — «пол»

Также обратите внимание, что данный метод возвращает значение типа double. На входе у нас было число 5.25, после округления мы получили 5.0 — тип double.

3. Math.ceil() — данный метод округляет число до ближайшего целого вверх. У нас было число 5.25, а вернул нам этот метод число 6.0 Даже если бы у нас было число 5.01, данный метод все равно вернул бы нам 6.0, потому что ближайшее целое число вверх — это 6.0

Вот почему данный метод называется ceil — от слова ceiling, «потолок». Также обратите внимание, что данный метод возвращает значение типа double.

Ниже приводим Вам табличку, где это все расписано схематически.

Также Вы должны знать методы Math.random(), Math.max () и Math.min() . Об этих методах Вы можете почитать вот в этих 2 статьях:

Понравилась статья? А еще можно у нас пройти курс обучения по Java. Детальнее на сайте Vertex Academy.

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

Однако полученный результат может отличаться от ожидаемого. В частности, в данном случае y будет равно 5, несмотря на то, что по всем правилам округления должно быть 6. Чтобы избежать этой многозначности, можно воспользоваться «дедовским» способом, без привязки к возможностям языка.

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

Если n имеет дробную часть менее 0,5, то число округляется в меньшую сторону, в противном случае — в большую. То есть стандартный математический алгоритм.

Если же вам требуется java округление в меньшую сторону — вместо дополнительной математической операции лучше сразу воспользоваться готовой функций FLOOR:

Java округление в большую сторону выполняется методом CEIL:

Как и в жизни, округлять можно не только до целого числа, но и до определенного знака после запятой. Как и в первом случае, в java округление до сотых можно сделать чисто математически:

Однако запись не слишком удобна, если вам требуется в java округление до плавающего числа знаков с заданным поведением. С помощью методов перечисления RoundingMode() у вас есть такая возможность. Методы следующие:

  1. UP — округление в сторону большего числа для положительных чисел и меньшего для отрицательных.
  2. DOWN — округление в сторону меньшего числа для положительных чисел и большего для отрицательных.
  3. CEILING — округление в сторону большего и для положительных, и для отрицательных чисел.
  4. FLOOR — округление в сторону меньшего и для положительных, и для отрицательных чисел.
  5. HALF_UP — округление в большую сторону в случае числа вида 0.5;
  6. HALF_DOWN — округление в меньшую сторону в случае числа вида 0.5;
  7. HALF_EVEN — классическое округление

Выглядит подобное округление чисел так:

Цифра в скобках указывает в java округление до 2 знаков double типа.

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

В Java есть целочисленные типы данных (long, int, char, short, byte) и есть типы с плавающей точкой (float, double), а по-русски — «с плавающей запятой» . Преобразование значений с дробной частью в целочисленные полезно для упрощения вычислений, последующего чтения и для сокращения объемов используемой памяти. Сделать это можно так:

Однако полученный результат может отличаться от ожидаемого. В частности, в данном случае y будет равно 5, несмотря на то, что по всем правилам округления должно быть 6. Чтобы избежать этой многозначности, можно воспользоваться «дедовским» способом, без привязки к возможностям языка.

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

Читать еще:  Char array to string java

Если n имеет дробную часть менее 0,5, то число округляется в меньшую сторону, в противном случае — в большую. То есть стандартный математический алгоритм.

Если же вам требуется java округление в меньшую сторону — вместо дополнительной математической операции лучше сразу воспользоваться готовой функций FLOOR:

Java округление в большую сторону выполняется методом CEIL:

Как и в жизни, округлять можно не только до целого числа, но и до определенного знака после запятой. Как и в первом случае, в java округление до сотых можно сделать чисто математически:

Однако запись не слишком удобна, если вам требуется в java округление до плавающего числа знаков с заданным поведением. С помощью методов перечисления RoundingMode() у вас есть такая возможность. Методы следующие:

  1. UP — округление в сторону большего числа для положительных чисел и меньшего для отрицательных.
  2. DOWN — округление в сторону меньшего числа для положительных чисел и большего для отрицательных.
  3. CEILING — округление в сторону большего и для положительных, и для отрицательных чисел.
  4. FLOOR — округление в сторону меньшего и для положительных, и для отрицательных чисел.
  5. HALF_UP — округление в большую сторону в случае числа вида 0.5;
  6. HALF_DOWN — округление в меньшую сторону в случае числа вида 0.5;
  7. HALF_EVEN — классическое округление

Выглядит подобное округление чисел так:

Цифра в скобках указывает в java округление до 2 знаков double типа.

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

Форум

Справочник

Поиск по форуму
Расширенный поиск
К странице.

Илья Кантор, 15 мар 2009 — 23:02

Math.round

Синтаксис

Аргументы

Описание, примеры

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

См. также

  • Math.ceil /Метод/
  • Math.floor /Метод/
  • toPrecision /Метод/
  • toFixed /Метод/

Очень жаль, что нет функции, которая округляет до нужного знака. В статье неплохо бы ее написать.

Округление до нужной точности после запятой

Для этого используется метод toFixed.
0.1234.toFixed(2) = 0.12

.toFixed() не всегда работает правильно.. в Firefox 21.0, Chrome, Safari и Opera результатом такой строки
parseFloat(71.175).toFixed(2) будет 71.17 .

а такое результатом выражения
Math.round(parseFloat(71.175) * 100) / 100 будет 71.18, т.е. результат правильно округленный

при этом IE на тех же выражениях выдает всегда 71.18 ! похоже «правильность» js еще и от браузера зависит

>не всегда работает правильно.
parseFloat(71.175).toFixed(2)=71.17

правильно, это называется «банковское округление», где при округлении 5 учитывается предшествующий знак, нечетные в меньшую, четные в большую сторону.
поэтому
parseFloat(71.185).toFixed(2) будет 71.19

это округление используется в .NET

Но это только для toFixed(2). Для toFixed(1) или toFixed(3) этот феномен не наблюдается

Не могу найти функцию, которая возвращает дробную часть числа

123.456 % 1
и взять цифр сколько там надо

можно еще так:
123.456.toString().split(/./)[1];

Стоит еще раз поставить ударение: toFixed возвращает строковое представление числа, а поскольку и сравнение и сложение для строковых переменных в JS возможно (последнее становится конкатенацией) то желательно применять что то вроде

Или более жестко:

Дельный совет, спасибо. Провернуть такое при помощи toFixed() почему-то не получилось.

Собственно функция round с нужной точностью, для страждущих:

Вот ещё один вариант, но за точность не ручаюсь:

> Собственно функция round с нужной точностью, для страждущих:

Все равно это не решает проблемы:
10000.345.round(1) = 10000.3

Отправить комментарий

Поиск по сайту
Содержание

Учебник javascript

Основные элементы языка

Сундучок с инструментами

Интерфейсы

Все об AJAX

Оптимизация

Разное

Последние комментарии
  • This article is nice. I like it. Thank.
    16 часов 30 минут назад
  • Thank you for such a well written.
    18 часов 2 минуты назад
  • If you set out to make me think today;.
    18 часов 2 минуты назад
  • I really enjoyed reading this post, big.
    1 день 4 часа назад
  • Superbly written article, if only all.
    1 день 4 часа назад
  • this is really nice to read.
    1 день 4 часа назад
  • i read a lot of stuff and i found that.
    1 день 4 часа назад
  • Waow this is quite pleasant article, my.
    1 день 20 часов назад
  • Intriguing post. I Have Been pondering.
    1 день 20 часов назад
  • Most of the time I don’t make comments.
    1 день 20 часов назад
Последние темы на форуме
Но если мы, к примеру, хотим запустить видео автоматически и без звука, фрейм будет таким: Как вы могли заметить к ссылке были добавлены необязательные параметры ?autoplay=0&mute=1 их мы и передаем в setting при использовании скрипта:

Ссылка на основную публикацию
Adblock
detector