Pro Java
Примитивные типы Java, как мы уже знаем, ограничены диапазоном значений, которые они могут представлять. Когда размеров (диапазона значений) примитивных типов не хватает, для представления тех или иных чисел, можно воспользоваться классами BigInteger и BigDecimal, которые могут работать с целыми или вещественными числами любой точности (разрядности). Хотя работа с ними может выглядеть несколько неуклюже по сравнению с примитивными типами и их обертками, но в замен мы получаем необходимую нам точность вычислений. Теперь рассмотрим все это более подробно. И хотя о классах мы еще не говорили, мне кажется более логичным рассмотреть эти два класса сразу после классов оберток, чтобы начать понимать что такое методы классов и как они работают, на примере замещения стандартных математических операторов на методы этих классов. Так же мы еще не говорили о массивах, которые тоже могут быть использованы для создания объектов этих классов, но надеюсь что все будет более или менее понятно.
Класс BigInteger
Все примитивные целые типы имеют ограниченный диапазон значений. В целочисленной арифметике Java нет переполнения, целые числа приводятся по модулю, равному диапазону значений. Для того чтобы было можно производить целочисленные вычисления с любой разрядностью, в состав Java API введен класс BigInteger, хранящийся в пакете java.math. Этот класс является потомком java.lang.Number и представляет целые числа произвольной длины, которая не ограничена 64 битами, как в типе long. Поскольку этот класс расширяет класс Number, следовательно, в нем переопределены методы doubleValue(), floatValue(), intValue(), longValue(). Методы byteValue() и shortValue() не переопределены, а прямо наследуются от класса Number.
Класс BigInteger содержит методы, дублирующие стандартные арифметические и побитовые операции Java. Метод compareTo() сравнивает два объекта BigInteger и возвращает результат сравнения в виде чисел −1, 0 или 1. Методы gcd(), modPow(), modInverse() и isProbablePrime() выполняют специальные операции и обычно применяются криптографическими и связанными с ними алгоритмами.
Класс BigInteger содержит множество других полезных методов, которые здесь перечислять мы не будем, так как их достаточно много и они хорошо задокументированы.
Действия с объектами класса BigInteger не приводят ни к переполнению, ни к приведению по модулю. Если результат операции велик, то число разрядов просто наращивается. Числа хранятся в двоичной форме с дополнительным кодом.
Шесть конструкторов класса создают объект класса BigInteger из строки символов (знака числа и цифр), массива байтов или задают случайное число. Приведу краткое описание этих конструкторов:
- BigInteger(String value) — объект будет хранить большое целое число, заданное строкой цифр, перед которыми может стоять знак минус;
- BigInteger(String value, int radix) — задается строка цифр со знаком value, записанная в системе счисления с основанием radix;
- BigInteger(byte[] value) — объект будет хранить большое целое число, заданное массивом value, содержащим двоичное представление числа в дополнительном коде;
- BigInteger(int signum, byte[] magnitude) – задает знак для числа заданного массивом byte, для signum возможны значения: –1 – для отрицательных чисел, 1 – для положительных и 0 для пустого массива;
- BigInteger(int bitLength, int certainty, Random rnd) – генерирует случайное число, на основе заданных параметров: bitLength – задает число бит в которые будет занимать созданное число (вызывает ArithmeticException если меньше 2 или слишком большое), два других параметра влияют на то как часто возможны повторения случайных чисел;
- BigInteger(int numBits, Random rnd) – так же генерирует случайное число, только используя два параметра.
Для преобразования обычного числа в число с произвольной точностью используется статический метод valueOf() с целочисленным литералом или целочисленной переменной, переданной методу как аргумент.
Три константы — ZERO, ONE и TEN — моделируют нуль, единицу и число десять в операциях с объектами класса BigInteger.
Метод toByteArray() преобразует объект в массив байтов.
Большинство методов класса BigInteger моделируют целочисленные операции и функции, возвращая объект класса BigInteger:
- abs() — возвращает объект, содержащий абсолютное значение числа, хранящегося в данном объекте this;
- add(x) — операция сложения this + x;
- and(x) — операция побитовой конъюнкции this & x;
- andNot(x) — операция побитовой дизъюнкции с дополнением this & (
Здесь далеко неполный перечень всех методов класса BigInteger. Все остальные можно посмотреть в документации на данный класс.
Стоит так же отметить что объекты классов BigInteger и BigDecimal являются immutable, то есть не изменяемыми . Это означает что методы данных классов не изменяют значение экземпляра класса, а лишь возвращают новое. Сейчас это может быть и не понятно, но практика все прояснит.
Теперь немного попрактикуемся для того, чтобы понять как работать с классом BigInteger. Чтобы использовать класс BigInteger в своей программе его необходимо импортировать командой
после чего его можно использовать.
И далее вывод данной программы:
Класс BigDecimal
Примитивные вещественные типы данных, так же как и целочисленные ограничены количеством разрядов которым они могут быть представлены. Кроме того вещественные числа в Java имеют свой большой набор граблей, которые не позволяют их использовать в вычислениях где требуются точные значения, например в финансах. Для обхода этих граблей и представления вещественных чисел с нужной точностью был создан класс BigDecimal. Этот класс является потомком java.lang.Number и представляет число с плавающей точкой произвольной длины и точности. Класс BigDecimal расположен в пакете java.math.
Каждый объект этого класса хранит два целочисленных значения: мантиссу вещественного числа в виде объекта класса BigInteger и неотрицательный десятичный порядок числа типа int. Например, для числа 76,34862 будет храниться мантисса 7 634 862 в объекте класса BigInteger и порядок 5 как целое число типа int. Таким образом, мантисса может содержать любое количество цифр, а порядок ограничен значением константы Integer.MAX_VALUE.
Класс BigDecimal содержит методы, дублирующие стандартные арифметические операции Java. Но методов работы с битами как в BigInteger у него нет. Метод compareTo() сравнивает два объекта BigInteger и возвращает результат сравнения в виде чисел −1, 0 или 1.
При работе со значениями BigDecimal можно явно указать нужную точность (то есть количество десятичных разрядов). Кроме того, при выполнении операции, отбрасывающей разряды (например, при делении), требуется указать тип округления, которому подвергается первый разряд слева от отбрасываемых разрядов. В этом классе определено восемь констант, соответствующих различным типам округления. Поскольку в этом классе можно работать с числами произвольной точности и явно указывать точность и вид округления, его можно применять при выполнении операций над числами, представляющими денежные суммы, а также в других случаях, когда нельзя допускать ошибки при округлении.
Результат операции над объектами класса BigDecimal округляется по одному из восьми правил, определяемых следующими статическими целыми константами:
- ROUND_CEILING — округление в большую сторону;
- ROUND_DOWN — округление в меньшую сторону по модулю;
- ROUND_UP — округление в большую сторону по модулю
- ROUND_FLOOR — округление в меньшую сторону;
- ROUND_HALF_DOWN — Округление вниз, если число после запятой > .5;
- ROUND_HALF_EVEN — Округление половины по чётности ;
- ROUND_HALF_UP — Округление вверх, если число после запятой >= .5;
- ROUND_UNNECESSARY — предполагается, что результат будет целым, и округление не понадобится;
Чуть позже мы рассмотрим все эти типы округления более подробно на примерах.
Три константы — ZERO, ONE и TEN — моделируют вещественные нуль, единицу и вещественное число десять в операциях с объектами класса BigDecimal. В классе BigDecimal около двадцати конструкторов и очень много методов, поэтому все их мы описывать не будем, а коснемся лишь некоторых.
Большинство методов этого класса моделируют операции с вещественными числами. Они возвращают объект класса BigDecimal. Ниже в описании методов буква x обозначает объект класса BigDecimal, буква n — целое значение типа int, буква r — способ округления, одну из восьми перечисленных ранее констант:
- abs() — абсолютное значение объекта this;
- add(x) — операция сложения this + x;
- divide(x, r) — операция деления this / x с округлением по способу r;
- divide(x, n, r) — операция деления this / x с изменением порядка и округлением по способу r;
- max(x) — наибольшее из this и x;
- min(x) — наименьшее из this и x;
- movePointLeft(n) — сдвиг точки влево на n разрядов;
- movePointRight(n) — сдвиг точки вправо на n разрядов;
- multiply(x) — операция умножения this * x;
- negate() — возвращает объект с обратным знаком;
- scale() — возвращает порядок числа;
- setScale(n) — устанавливает новый порядок n;
- setScale(n, r) — устанавливает новый порядок n и округляет число при необходимости по способу r;
- signum() — знак числа, хранящегося в объекте;
- subtract(x) — операция вычитания this — x;
- toBigInteger() — округление числа, хранящегося в объекте;
- unscaledValue() — возвращает мантиссу числа;
- upl() — возвращает расстояние до следующего числа.
Как я уже говорил, здесь перечислены далеко не все методы класса BigDecimal. Остальные можно посмотреть в описании к этому классу.
Чаще всего класс BigDecimal используют в финансовых расчётах, так как вещественные примитивные типы не годятся для этой цели по причинам потери точности которые я уже описывал. Но вкратце все же напомню на следующем примере:
Вывод у этого кода следующий:
Как видим результат на лицо 🙂
Такие вещи, на которые способен double, в финансах ни кому не понравятся.
Денежные расчёты требуют точности в заданной степени, например, для большинства валют это два знака после запятой. Они также требуют определённого типа поведения при округлении, например, в случае налогов всегда выполнять округление в большую сторону.
Например, предположим, что у нас есть продукт, который стоит 10.00 в заданной валюте и местный налог с продаж 0.0825, или 8.25%. Если посчитать налог на бумаге, сумма будет:
10.00 * 0.0825 = 0.825
Но если мы эти числа зададим как double то в результате умножения получим число 0.8250000000000001.
Поскольку точность расчёта для данной валюты две цифры после запятой, требуется округлить число 0.825. Кроме того, поскольку это налог, обычной практикой является постоянное округление до цента в большую сторону. Таким образом, после расчёта баланса по счетам в конце дня мы никогда не получим недоплату налогов.
И таким образом клиенту выставляется общий счёт на сумму 10.83 в местной валюте, а сборщику налогов выплачивается 0.83. Обратите внимание, что если продать 1000 таких продуктов, то переплата сборщику налогов была бы:
1000 * (0.83 — 0.825) = 5.00
Другой важный вопрос: где делать округление в данном расчёте. Предположим, жидкий азот продаётся по цене 0.528361 за литр. Клиент приходит и покупает 100.00 литров, поэтому посчитаем полную цену:
100.0 * 0.528361 = 52.8361
Так как это не налог, можно округлить эту цифру вверх или вниз на своё усмотрение. Предположим, округление выполняется в соответствии со стандартными правилами округления: если следующая значащая цифра меньше 5, округляем в меньшую сторону. В противном случае округляем вверх. Это даёт для окончательной цены значение 52.84.
Теперь предположим, что мы хотим дать рекламную скидку в размере 5% от всей покупки. Делать скидку с цифры 52.8361 или 52.84? Какова разница?
Расчёт 1: 52.8361 * 0.95 = 50.194295 = 50.19
Расчёт 2: 52.84 * 0.95 = 50.198 = 50.20
Обратите внимание, что окончательная цифра округлена по стандартному правилу округления.
Видите разницу в один цент между двумя цифрами? Первый код не беспокоился о принятии во внимание округления, поэтому он всегда делал вычисления как в Расчёте 1. Но во втором коде перед расчётом скидок, налогов и всего другого сначала выполняется округление 2. Это одна из главных причин для ошибки в один цент.
Из этих примеров должно стать ясным, что необходимы две вещи:
1.Возможность задать масштаб, который представляет собой количество цифр после десятичной точки
2.Возможность задать метод округления
Класс BigDecimal принимает во внимание оба этих соображения.
Создать BigDecimal из числа типа double просто:
BigDecimal bd3 = new BigDecimal ( 0.3 ) ;
Но если мы выведем это число на консоль, то результат будет не тот что мы ожидали:
Поэтому более лучшей идеей является создание из строки:
bd3 = new BigDecimal ( «0.3» ) ;
Вот теперь будет порядок 🙂 и мы получим то что ожидали.
Теперь перейдем к округлению.
Чтобы задать количество цифр после запятой, используйте метод .setScale(scale). Тем не менее, хорошей практикой является одновременное указание вместе с масштабом режима округления с помощью .setScale(scale, roundingMode). Режим округления задаёт правило округления числа.
bd3 = new BigDecimal ( 0.3 ) ;
bd3 . setScale ( 1 ) ; //выдаст ошибку
Вторая строка выдаст ошибку java.lang.ArithmeticException: Rounding necessary, поскольку не известно как округлить 0.299999999999999988897769753748434595763683319091796875.
Так что всегда использовать .setScale(scale, roundingMode) — это хорошая идея. Например:
bd3 . setScale ( 1 , BigDecimal . ROUND_CEILING );
Если это значение вывести на консоль, то получим 0.3.
Ну и теперь подробно разберем все восемь типов округления класса BigDecimal.
ROUND_CEILING : В большую сторону
ROUND_DOWN: Отбрасывание разряда
ROUND_FLOOR: В меньшую сторону
ROUND_HALF_UP: Округление вверх, если последнее число после запятой >= .5
ROUND_HALF_DOWN: Округление вниз, если последнее число после запятой > .5
ROUND_HALF_EVEN: Округление половины по чётности округляет как обычно. Однако, когда округляемая цифра 5, округление будет идти вниз, если цифра слева от 5 чётная и вверх, если нечётная.
Документация Java говорит о ROUND_HALF_EVEN так: обратите внимание, что это такой режим округления, который сводит к минимуму совокупную ошибку когда при выполнении последовательности вычислений постоянно выполняется округление .
ROUND_UNNECESSARY: Используйте ROUND_UNNECESSARY когда необходимо использовать один из методов, который требует ввода режима округления, но известно, что результат округлять не надо. Кроме того если задано количество знаков после запятой меньше чем в округляемом числе то вылетит ошибка.
При делении BigDecimals будьте осторожны и указывайте способ округления в методе .divide(). В противном случае можно получить ArithmeticException, если нет точного округлённого результирующего значения, например, 1/3. Таким образом, всегда следует делать так:
BigDecimal bd01 = new BigDecimal ( «1» ) ;
BigDecimal bd03 = new BigDecimal ( «3» ) ;
//BigDecimal bd1d3 = bd01.divide(bd03); // вызовет ошибку ArithmeticException
BigDecimal bd1d3 = bd01 . divide ( bd03 , 5 , BigDecimal . ROUND_HALF_UP ) ;
Теперь стоит пояснить более подробно что же такое immutable. Как я уже говорил это означает что созданные объект BigDecimal неизменяем. Это означает, что если создаётся новый объект BigDecimal со значением «2.00», такой объект останется «2.00» и никогда не может быть изменён. Так как же тогда выполняются математические расчёты? Методы .add(), .multiply() и другие возвращают новый объект BigDecimal, содержащий результат.
Так же стоит заметить что важно никогда не использовать для сравнения объектов BigDecimal метод .equals() . Этого нельзя делать потому, что метод equals() будет сравнивать масштабы. Если масштабы различаются, .equals() вернёт ложь, даже если они математически равны :
BigDecimal a = new BigDecimal ( «2.00» ) ;
BigDecimal b = new BigDecimal ( «2.0» ) ;
print ( «a.equals(b) 2″> + a . equals ( b )) ; // ложь
Поэтому вместо этого следует использовать методы .compareTo() и .signum().
a . compareTo ( b ) ; // возвращает (-1 если a < b), (0 если a == b), (1 если a > b)
a . signum () ; // возвращает (-1 если a < 0), (0 если a == 0), (1 если a > 0)
Ну и на последок расскажу о полезном методе .stripTrailingZeros() который убирает незначащие нули в конце BigDecimal.
BigDecimal bd_1 = new BigDecimal ( «1.55» ) ;
BigDecimal bd_2 = new BigDecimal ( «3.15» ) ;
BigDecimal bd_3 = bd_1 . add ( bd_2 ) ;
println ( «bd_3 2″> + bd_3 ) ;
println ( «bd_3 2″> + bd_3 . stripTrailingZeros ()) ;
Пример работы данного когда будет приведен ниже, а пока смотрим на код, который демонстрирует все вышесказанное о BigDecimal:
Вывод данной программы:
Подробно расписывать какие строки кода что выводят я думаю нет необходимости. Все и так понятно из кода.
Хотя эти два класса и важная тема, но она достаточно обширна, а нам надо двигаться дальше.
Числовые типы данных и операции
Каждый тип данных имеет диапазон значений. Компилятор выделяет пространство памяти для каждой переменной или константы в соответствии с её типом данных. Java предоставляет восемь примитивных типов данных для числовых значений, символов и логических значений. В этом разделе представлены числовые типы данных и операторы.
В таблице перечислены шесть числовых типов данных, их диапазоны и размеры их хранения.
Отрицательный диапазон: от -3.4028235E + 38 до -1.4E — 45
Положительный диапазон: от 1.4E — 45 до 3.4028235E + 38
Отрицательный диапазон: от -1.7976931348623157E + 308 до -4.9E — 324
Положительный диапазон: от 4.9E — 324 до 1.7976931348623157E + 308
Примечание: IEEE 754 является стандартом, утвержденным Институтом инженеров по электротехнике и электронике для представления на компьютерах чисел с плавающей запятой. Стандарт широко принят. Java использует 32-разрядный IEEE 754 для типа float и 64-разрядный IEEE 754 для типа double. Стандарт IEEE 754 также определяет специальные значения с плавающей запятой, которые перечислены в Приложении E.
Целочисленные типы
Java использует четыре типа целых чисел: byte, short, int и long. Выбирайте тип, который больше всего подходит для вашей переменной. Например, если вы знаете, что целое число, хранимое в переменной, находится в диапазоне байта, объявите переменную как byte. Для простоты и последовательности, большую часть времени на этом сайте мы будем использовать для целых чисел тип int.
Типы с плавающей запятой
Java использует два типа чисел с плавающей запятой: float и double. Тип double в два раза больше чем float. Поэтому double известен как число с двойной точностью, а float – как число с одинарной точностью. Обычно вам следует использовать тип double, поскольку он более точен чем тип float.
2. Считывание чисел с клавиатуры
Вы знаете как использовать метод nextDouble() из класса Scanner для считывания значения double с клавиатуры. Вы также можете использовать методы, представленные в следующей таблице, для чтения чисел типов byte, short, int, long и float:
| Метод | Описание |
|---|---|
| nextByte() | прочитать число типа byte |
| nextShort() | прочитать число типа short |
| nextInt() | прочитать число типа int |
| nextLong() | прочитать число типа long |
| nextFloat() | прочитать число типа float |
| nextDouble() | прочитать число типа double |
Далее примеры для чтения данных различного типа с клавиатуры:
Если вы введёте значение из некорректного диапазона или формата, случиться ошибка выполнения. Например, в строке 3 вы введёте 128, произойдёт ошибка, поскольку 128 находится вне диапазона чисел типа byte.
3. Числовые операторы
Операторы +, -, *, /, % и операнды
Операторы для числовых типов данных включают стандартные арифметические операторы: сложение (+), вычитание (–), умножение (*), деление (/) и остаток от деления (%).
| Имя | Значение | Пример | Результат |
|---|---|---|---|
| + | Сложение | 34 + 1 | 35 |
| — | Вычитание | 34.0 — 0.1 | 33.9 |
| * | Умножение | 300 * 30 | 9000 |
| / | Деление | 1.0 / 2.0 | 0.5 |
| % | Остаток от деления | 20 % 3 | 2 |
Целочисленное деление
Когда оба операнда деления (делимое и делитель) являются целыми числами, результатом деление будет частное без дробной части. Например, 5 / 2 даёт 2, а не 2.5, а -5 / 2 даёт -2, а не -2.5. Для выполнения деления с плавающей точкой один из операндов должен быть числом с плавающей запятой. Например, 5.0 / 2 даёт 2.5.
Оператор %, известный как остаток от деления, или оператор модуля, даёт остаток после деления. Операндом слева – это делимое, а операнд справа – делитель. Поэтому 7 % 3 даёт 1, 3 % 7 даёт 3, 12 % 4 даёт 0, 26 % 8 даёт 2 и 20 % 13 даёт 7.
Оператор % часто используется для положительных целых чисел, но также может использоваться для отрицательных и значений с плавающей запятой. Остаток от деления является отрицательным только если отрицательным является делимое. Например, -7 % 3 даёт -1, -12 % 4 даёт 0, -26 % -8 даёт -2 и 20 % -13 даёт 7.
Остаток от деления очень полезен в программировании. Например, чётные числа % 2 всегда 0, а нечётные числа % 2 всегда 1. Так вы можете использовать это свойство для определения, является ли число чётным или нечётным. Если сегодня суббота, то суббота снова будет через 7 дней. Предположим, вы и ваши друзья собираетесь встретиться через 10 дней. Какой день будет через 10 дней? Вы можете узнать, что будет вторник используя следующее выражение:
Следующая программа считает сколько минут и секунд содержится в количестве введённых секунд. Например, 500 секунд содержат 8 минут и 20 секунд.
Метод nextInt() (строка 8) считывает число для seconds. Строка 10 получает минуты используя seconds / 60. Строка 11 (seconds % 60) получает оставшиеся секунды без минут.
Унарные и бинарные операторы
Операторы + и — могут быть как унарными, так и бинарными. Унарный оператор имеет только один операнд; а бинарные – два. Например, оператор — в -5 – это унарный оператор, показывающей, что число 5 является отрицательным, в то время как оператор — в 4 — 5 является бинарным оператор для вычитания 5 из 4.
4. Операции возведения в степень
Метод Math.pow(a, b) может использоваться для вычисления a b . Метод pow определён в классе Math в Java API. Этот метод вызывается с использованием синтаксиса Math.pow(a, b) (например, Math.pow(2, 3)), который возвращает результата a b (2 3 ). Здесь a и b являются параметрами для метода pow, а числа 2 и 3 настоящими значениями, используемыми для вызова метода. Например:
В одной из последующих главах будут даны дополнительные подробности о методах. На данный момент всё, что вам нужно знать, это как вызывать метод pow для выполнения операций возведения в степень.
Извлечение цифр int в Java
Как я смогу проанализировать число и получить 1, 2 и 8 и назначить их различным переменным?
13 ответов
неэффективный способ сделать это, чтобы преобразовать целое число в строку и перебирать строку символов.
более эффективным способом было бы что-то вроде:
ответ, который написал Тило, хорош, но неполон, вы начинаете делать:
Теперь digits содержит цифры числа в виде массива int
превратить его в строку и перейти символ за символом для цифр:
конечно, если целое число имеет более трех цифр, использование цикла было бы более практичным:
с вышеуказанным кодом на месте, легко извлечь цифры из массива:
соберите все цифры в массиве и используйте futher
выход должен быть!—3—>
вот чисто математический способ сделать это:
например, если input = 1234 и pos = 2 , потом i is 34 . Мы делим 34 by 10 и округлить, чтобы получить 3 .
не так красиво, но работает!
вы можете получить 1,2,8 от этого str
этот код возвращает nibble по заданному индексу. Если вы хотите получить все цифры, вы можете вызвать этот метод со всеми показателями вашего номера. Он работает не на шестнадцатеричном представлении числа,а на десятичном.
теперь, если вы пытаетесь выделить числа в строке среди букв, это должно позаботиться об этом.
Это должно возвратить 110
кроме того, вот ссылка на обсуждение стека, которое я нашел действительно полезным. получить int из строки, также содержащей буквы, в Java
Если вы не цените идею String преобразование и хотите повторить, используя нормальный порядок, попробуйте следующее: