Числовые литералы
Например, 34 и 0.305 это литералы в следующих инструкциях:
int numberOfYears = 34; double weight = 0.305;
1. Целочисленные литералы
Целочисленный литерал может быть присвоен числовой переменной при условии, что он соответствует типу переменной. Если литерал слишком велик для хранения в переменной, то произойдёт ошибка компиляции. Инструкция byte b = 128, например, приведёт к ошибке компиляции, поскольку 128 не может быть сохранено в переменной типа byte (помните, что диапазон для значения byte с -128 до 127.)
Предполагается, что целочисленный литерал имеет тип int, значение которого находится между-2 31 (-2147483648) и 2 31 — 1 (2147483647). Для указания целочисленному литералу быть типом long, добавьте к нему букву L или l. Например, для написания в программе Java числа 2147483648, вы должны написать 2147483648L или 2147483648l, поскольку 2147483648 выходит за рамки диапазона значений int. Предпочтительней L поскольку l (L в нижнем регистре) легко может быть спутана с 1 (цифрой один).
Справка: по умолчанию целочисленный литерал является десятичным целым числом. Для обозначения двоичного целочисленного литерала используйте перед ним 0b или 0B (ноль B), для обозначения восьмеричного целочисленного литерала, используйте перед ним 0 (ноль), а для обозначения шестнадцатеричного целочисленного литерала, используйте перед ним 0x или 0X (ноль X). К примеру:
System.out.println(0B1111); // Отобразит 15 System.out.println(07777); // Отобразит 4095 System.out.println(0XFFFF); // Отобразит 65535
Шестнадцатеричные цифры, двоичные цифры и восьмеричные цифры представлены в Приложении F.
2. Литералы с плавающей запятой
Литералы с плавающей запятой пишутся с десятичной точкой. По умолчанию литералы с плавающей запятой (точкой) обрабатываются как значения типа double. Например, 5.0 считается значением double, а не float. Вы можете сделать число float добавив букву f или F, и вы можете сделать число double добавив букву d или D. Например, вы можете использовать 100.2f или 100.2F для числа float, и 100.2d или 100.2D для числа double.
double или float
Примечание: значения типа double являются более точными, чем значения типа float. Например:
System.out.println("1.0 / 3.0 это " + 1.0 / 3.0); Отобразит 1.0 / 3.0 это 0.3333333333333333 (16 цифр после запятой).
System.out.println("1.0F / 3.0F это " + 1.0F / 3.0F); Отобразит 1.0F / 3.0F это 0.33333334 (8 цифр после запятой).
Значение float имеет от 7 до 8 значимых цифр, а значение double имеет от 15 до 17 значимых цифр.
3. Экспоненциальная запись
Литералы с плавающей запятой могут быть записаны в научной нотации (экспоненциальной записи) в форме a * 10 b . Например, экспоненциальная запись для 123.456 это 1.23456 * 10 2 , а для 0.0123456 это 1.23456 * 10 -2 . Для экспоненциальной записи цифр используется специальный синтаксис. Например, 1.23456 * 10 2 пишется как 1.23456E2 или 1.23456E+2, а 1.23456 * 10 -2 как 1.23456E-2.
E (или e) представляет экспоненту и может быть как в нижнем, так и в верхнем регистре.
Справка: для представления чисел с плавающей точкой используются типы float и double. Почему они называются числами с плавающей точкой (или с плавающей запятой)? Когда 50.534 преобразовывается в экспоненциальную запись, такую как 5.0534E+1, его десятичная точка перемещает (т.е. переплывает) на новую позицию.
Помните: для улучшения читаемости, Java позволяет использовать знаки подчёркивания между двумя цифрами в числовых литералах. Например, следующие литералы корректны:
long ssn = 232_45_4519; long creditCardNumber = 2324_4545_4519_3415L;
При этом, 45_ или _45 являются неверными. Знак подчёркивания должен находится между двумя цифрами.
Округление чисел в Java
Числа с плавающей точкой (float, double) применяются при вычислении выражений, в которых требуется точность до десятичного знака. Высокая точность часто нужна в бухгалтерских и других вычислительных операциях. Но всегда ли нам нужен длинный “хвост” чисел после запятой? Может нам достаточно точности в три знака вещественной части? И есть нас такой вариант устраивает, как правильно выполнить округление? Именно об этом мы сегодня и поговорим: рассмотрим способы округления чисел в Java .
String format
double value = 34.766674; String result = String.format("%.3f",value); System.out.print(result);// 34,767 В результате мы отформатируем наше число с плавающей запятой 34766674 с точностью до 3 десятичных разрядов , так как в инструкции для форматирования мы указали три знака после запятой «%.3f. В свою очередь %f при форматировании строки обозначает тип чисел с плавающей запятой, которое включает в себя тип данных double и float в Java. В примере выше мы выводили полученное значение в консоль. Теперь вопрос: как бы можно было это сократить? Все просто: нужно использовать printf, который в свою очередь является format + print. В итоге предыдущий пример у нас сократился бы до:
double value = 34.766674; System.out.printf("%.3f",value); У экземпляра out класса PrintStream помимо этого метода есть ещё метод format, который работает аналогично:
double value = 34.766674; System.out.format("%.3f",value); Округление происходит по режиму HALF_UP — в сторону числа, которое ближе к обрезаемому (к 0 или 10). Если же эти числа равноудалены (в случае с 5), то округление выполняется в большую сторону. Пример:
String firstResult = String.format("%.3f",7.0004);// 7,000 String secondResult = String.format("%.3f",7.0005);// 7,001 String thirdResult = String.format("%.3f",7.0006);// 7,001 
Более подробно режимы округления мы разберем чуть ниже.
DecimalFormat
Еще один вариант — использовать класс DecimalFormat. Он предназначен для форматирования любого числа в Java, будь это целое число или число с плавающей запятой. При создании экземпляра DecimalFormat мы можем передать ему строку форматирования. Она укажет, сколько десятичных разрядов нужно отформатировать для ввода. Как будет выглядеть наш пример с использованием DecimalFormat :
double value = 34.766674; DecimalFormat decimalFormat = new DecimalFormat( "#.###" ); String result = decimalFormat.format(value); System.out.print(result);//34,767 Строка #.### — это шаблон, который указывает, что мы форматируем передаваемое значение до 3 десятичных знаков. Чтобы изменить шаблон после создания объекта DecimalFormat, можно использовать его методы applyPattern и applyLocalizedPattern :
DecimalFormat decimalFormat = new DecimalFormat("#.###"); decimalFormat.applyPattern("#.#"); decimalFormat.applyLocalizedPattern("#.#####"); Но мы сегодня говорим про округление, не правда ли? При обрезании числа с знаками после запятой, выходящими за заданный шаблон, DecimalFormat округляет число в большую сторону, если последний обрезаемое число больше 5. Но что если число — 5? Получается, что оно ровно посередине между ближайшими целыми. Что тогда? В этом случае учитывается предыдущее число. Если оно чётное, округление производится:
DecimalFormat decimalFormat = new DecimalFormat("#.###"); String result = decimalFormat.format(7.4565); System.out.println((result));// 7,457 DecimalFormat decimalFormat = new DecimalFormat("#.###"); String result = decimalFormat.format(7.4575); System.out.println((result));// 7,457 Есть небольшая разница между форматированием чисел с плавающей запятой с использованием String.format() и DecimalFormat.format(). Первый всегда будет печатать конечные нули, даже если нет дробной части. К примеру:
String firstResult = String.format("%.3f", 7.000132); System.out.println((firstResult)); // 7.000 DecimalFormat decimalFormat = new DecimalFormat("#.###"); String secondResult = decimalFormat.format(7.000132); System.out.println((secondResult)); // 7 Как мы видим, при форматировании числа 7.000132 с точностью до трёх десятичных разрядов, метод format() у String выводит 7.000, в то время как у DecimalFormat метод format() выведет 7. То есть вы можете выбирать String.format() или DecimalFormat.format() в зависимости от того, нужны ли вам конечные нули или нет. Применяя вышеописанные способы, мы получали результат в виде строки. Давайте же рассмотрим способы, как можно получить обратно именно числовые значения.
Math
Нельзя не упомянуть специальный класс, заточенный под разные арифметические операции с числами — Math. В этом классе есть и методы для округления, но в отличие от уже описанных, они не позволяют задать определенное число знаков после запятой, а округляют до целого числа:
- Math.ceil() округляет до ближайшего целого числа вверх, но отдаёт не целочисленный тип, а double:
double value = 34.777774; double result = Math.ceil(value); System.out.println((result)); //35.0 Даже если у нас будет 34.0000000, все равно после использования Math.ceil мы получим 35,0. Math.floor() округляет до ближайшего целого вниз, также результатом отдаёт double:
double value = 34.777774; double result = Math.floor(value); System.out.println((result)); //34.0 double value = 34.777774; int result = Math.round(value); System.out.println((result)); //35 Если у нас число 34.5, округление выполняется до 35, если же чуть чуть меньше 34.499, число обрезается до 34. Чтобы не просто обрезать всю вещественную часть, а регулировать этот процесс до определенного количества знаков и при этом округлять, число умножают на 10^n (10 в степени n), где n равно количеству необходимых знаков после запятой. После этого применяют какой-нибудь метод класса Math для округления, ну а затем снова делят на 10^n:
double value = 34.777774; double scale = Math.pow(10, 3); double result = Math.ceil(value * scale) / scale; System.out.println((result)); //34.778 Округление с BigDecimal
BigDecimal — это класс, который позволяет работать с числами с плавающей запятой. В частности, его основной фишкой является то, что в нём можно хранить дробные числа произвольной длины (то есть нет ограничения в диапазоне числа). Помимо этого, этот класс хранит различные методы для арифметической обработки, включая округление. Класс данного объекта можно создать, задав в конструктор double, string отображение числа с плавающей запятой, double и MathContext и так далее. MathContext — комбинация правила округления RoundingMode и числа, описывающая общее количество цифр в искомом значении. Правила округления RoundingMode: DOWN — округление в сторону до нуля. UP — режим округления от нуля. CEILING — округление в сторону положительной бесконечности. FLOOR — округление в сторону к отрицательной бесконечности. HALF_UP — округление до «ближайшего соседа», если оба соседа не равноудалены (то есть когда округляемое число — 5). В этом случае выполняется округление вверх. HALF_DOWN — округление в сторону «ближайшего соседа». Если оба соседа не равноудалены, в этом случае округление вниз. HALF_EVEN — округление до «ближайшего соседа», если оба соседа не равноудалены. В этом случае округляются до четного соседа (как в описанном выше DecimalFormat). UNNECESSARY — используется для подтверждения того, что запрошенная операция имеет точный результат. Следовательно, округление не требуется. Пример:
MathContext context = new MathContext(5, RoundingMode.HALF_UP); double value = 34.777554; BigDecimal result = new BigDecimal(value, context); System.out.println(result); //34.778 Помимо возможности задавать правило округления в конструкторе, BigDecimal позволяет задать режим округления уже после создания экземпляра. Для этого используется метод setScale , в который нужно задать количество знаков после запятой и правила округления:
double value = 34.777554; BigDecimal result = new BigDecimal(value); result = result.setScale(3, RoundingMode.DOWN); System.out.println(result); //34.777 Также у BigDecimal есть внутренние int переменные, предназначенные для задания режима округления ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR . ) Представляют собой правила округления, аналогичные представленным в классе RoundingMode и аналогично используются в setScale :
BigDecimal result = new BigDecimal(value); result = result.setScale(3, BigDecimal.ROUND_DOWN);