Android studio округление чисел

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

Округление в Java: обзор

В этой статье мы рассмотрим, как в Java округлить число до n десятичного знаков.

Десятичные числа в Java

Java предоставляет два примитивных типа, которые могут использоваться для хранения десятичных чисел: float и double . Double — это тип данных, используемый по умолчанию:

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

Форматирование десятичного числа

Если нужно вывести десятичное число с n знаками после запятой, можно отформатировать выходную строку:

Также можно округлить значение с помощью класса DecimalFormat :

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

Java: округление Double с помощью BigDecimal

Чтобы округлить тип double до n знаков после запятой, можно написать helper-метод :

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

Можно сделать то же самое, используя библиотеку Apache Commons Math :

Актуальную версию этой библиотеки можно найти здесь . Для округления чисел применяется метод Precision.round() , который принимает два аргумента — значение и масштаб:

По умолчанию он использует тот же метод округления HALF_UP, что хэлпер. Поэтому результаты должны быть одинаковыми.

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

Округление чисел с плавающей запятой с помощью DoubleRounder

DoubleRounder — это утилита из библиотеки decimal4j . Она предоставляет быстрый метод округления double чисел до 18 знаков после запятой.

Последнюю версию библиотеки можно найти здесь . Чтобы подключить ее, добавьте зависимость в файл pom.xml :

Пример использования утилиты:

Но DoubleRounder дает сбой в нескольких сценариях. Например:

Метод Math.round() java

При использовании метода Math.round() можно контролировать п -количество десятичных разрядов путем умножения и деления на 10^п :

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

Заключение

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

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

Код, использованный в этой статье, доступен на GitHub .

Пожалуйста, опубликуйте ваши мнения по текущей теме материала. Мы крайне благодарны вам за ваши комментарии, дизлайки, отклики, лайки, подписки!

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

Источник

Округление в 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 — классическое округление
Читайте также:  Телевизор 50 skyworth 50g2a 4k ai tv android

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

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

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

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

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

Источник

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

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

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

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

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

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

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

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

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

Читайте также:  Как обновит андроид htc

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

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

Читайте также:  Инженерное меню android 9 pie

Существует ещё одно магическое число в поле порядка — 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 строку с уже исправленной погрешностью.

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

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

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

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

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

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

Источник

Оцените статью