|
|
Опубликовано 07.04.2015 14:53:05
|
|
|
В java предоставляются классы операций для больших чисел, а именно класс java.math.BinInteger и класс java.math.BigDecimal. Эти два класса используются для высокоточных вычислений: класс BigInteger — класс обработки для больших целых чисел, класс BigDecimal — для больших и малых чисел. Ниже мы представляем класс BigDecimal:
Реализация BigDecimal использует преимущества BigIntimal, за исключением того, что BigDecimal добавляет понятие десятичных чисел. Общие данные float и double type можно использовать только для научных или инженерных расчётов, поскольку в коммерческих вычислениях требуемая числовая точность относительно высока, поэтому используется класс java.math.BigDecimal, который поддерживает любую точность фиксированных точек и может применяться для точного расчёта валютных значений. Ниже мы кратко представим его использование с примерами
java.math.BigDecimal
Сегодня я написал программу о двоичном и десятичном преобразовании, опираясь на учебник, и алгоритм программы не сложный, но после написания я понял, что независимо от 2 в 10 или от 10 к 2, это плохое преобразование для чисел больше 2,1 миллиарда, то есть больше целого числа. станет 0.
Справочники обнаружили, что использование BigWholeeger решает эту проблему.
Поэтому я посмотрел JDK, проверил его несколько раз и в итоге успешно написал!
Опыт использования следующий:
1. BigInteger относится к java.math.BigInteger, поэтому импортируйте этот класс перед каждым использованием. Иногда я забывал импортировать в начале, поэтому запрос не находился в постоянном запросе.
2. Существует множество методов строительства, но теперь они иногда используются:
BigInteger(String val)
Преобразите десятичное представление строки BigInteger в BigInteger.
BigInteger(String val, int radix)
Преобразует строковое представление BigInteger для указанной мощности в BigInteger.
Чтобы преобразовать 2 int типа в BigInteger type, напишите BigInteger two=new BigInteg("2"); Примечание 2: двойные кавычки не могут быть опущены
3. Класс BigInteger моделирует все математические операции int-типа, такие как add()=="+", divide()=="-" и т.д., но следует отметить, что его содержимое нельзя напрямую использовать для математических операций при выполнении математических операций и должен использовать внутренние методы. И его операнд тоже должен быть типа BigInteg.
Например: two.add(2) — некорректная операция, потому что 2 не становится типом BigWholeer.
4. Когда вы хотите вывести результаты вычисления, следует использовать метод .toString для преобразования его в десятичную строку, как подробно описано ниже:
String toString()
Возвращает десятичное представление строки этого BigInteg.
Метод вывода: System.out.print(two.toString());
5. Объясните три используемые функции.
BigInteger remainder(BigInteger val)
Возвращает BigWholeeger со значением (этот % val).
BigInteger negate()
BigInteger возвращает значение (-this).
int compareTo(BigInteger val)
Сравните это BigInteger с указанным BigInteger.
Остаток используется для поиска остатка.
Negate превращает операнд в противоположность.
Сравнение подробно объясняется следующим образом:
сравнитьС
public int compareTo(BigInteger val)
Сравните это BigInteger с указанным BigInteger. Этот метод предпочтительно подходит для каждого из шести булевых операторов сравнения (<, ==, >, >=, !=, <=). Рекомендуемое утверждение для выполнения этих сравнений выглядит следующим образом: (x.compareTo(y) <op> 0), где — <op> один из шести операторов сравнения.
Спецификатор:
<BigInteger> Сопоставимый интерфейс
Параметры:
val — BigInteger, который сравнивает это BigInteger с ним.
Назад:
Заголовок: Реализация точных вычислений чисел с плавающей запятой в Java AYellow (Оригинальная) модификация
Ключевые слова: Java, точное вычисление с плавающей запятой
Вопрос:
Что бы мы увидели, если бы скомпилировали и запустили следующую программу?
Тест публичного класса{
public static void main(String args[]){
System.out.println(0.05+0.01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println(123.3/100);
}
};
Вы правильно прочитали! Результат, действительно, таков:
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Простые плавающие и двойные типы в Java недоступны. Эта проблема встречается не только в Java, но и во многих других языках программирования. В большинстве случаев расчёты точны, но можно попробовать ещё несколько раз (можно сделать цикл), чтобы ошибиться, как описанная выше. Теперь я наконец понимаю, почему существует код BCD.
Эта проблема довольно серьёзна: если у вас есть 9,9999999999999999 юаней, ваш компьютер не подумает, что вы сможете купить товар за 10 юаней.
Некоторые языки программирования предоставляют специализированные типы валют для решения этой ситуации, но Java этого не делает. Теперь посмотрим, как это исправить.
Округление
Наша первая реакция — делать круг. Метод круглости в классе по математике нельзя установить на несколько десятичных знаков, мы можем сделать только так (оставить два знака):
Публичный двойной раунд(двойное значение){
return Math.round(value*100)/100.0;
}
К сожалению, вышеуказанный код не работает, передача 4.015 в этот метод вернёт 4.01 вместо 4.02, как мы видели выше
4.015*100=401.4999999999999
Поэтому, если мы хотим точно округлять, мы не можем использовать простые типы для выполнения операций
java.text.decimalFormat тоже не решает эту проблему:
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
Выходная мощность — 4.02
BigDecimal
Этот принцип также упоминается в книге «Эффективная Java»: float и double можно использовать только для научных или инженерных вычислений, а в бизнес-вычислениях нужно использовать java.math.BigDecimal. Существует 4 способа построить BigDecimal, нам не важны два из тех, что сделаны с помощью BigIntecall, поэтому есть ещё два, а именно:
BigDecimal (двойная val)
Переводит двойник в BigDecimal.
BigDecimal (String val)
Переводит String-репрезентация BigDecimal в BigDecimal в BigDecimal.
API кратко описан и обычно проще в использовании. Мы можем использовать его, даже не задумываясь, в чём будет проблема? Когда что-то пошло не так, я узнал, что в подробном описании того, какой из вышеуказанных методов достаточен:
Примечание: результаты этого конструктора могут быть несколько непредсказуемыми. Можно предположить, что новый BigDecimal(.1) точно равен .1, но на самом деле он равен .1000000000000000055511151231257827021181583404541015625. Это так, потому что .1 нельзя точно представить как двойную (или, если уж на то пошло, как бинарную дробь любой конечной длины). Таким образом, длинное значение, передаваемое конструктору, не равно точно 0,1, несмотря на видимость.
Конструктор (String), напротив, вполне предсказуем: новый BigDecimal («.1») точно равен .1, как и следовало ожидать. Поэтому обычно рекомендуется использовать конструктор (String) вместо этого.
Оказывается, если нужно точно рассчитать, нужно использовать String для создания BigDecimal! Пример в книге Effective Java использует String для создания BigDecimal, но книга не акцентирует на этом, что может быть небольшой ошибкой.
Решение
Теперь, когда мы решили эту проблему, принцип в том, чтобы использовать BigDecimal и обязательно использовать String.
Но представьте, что если мы хотим выполнить операцию сложения, сначала нужно преобразовать два числа с плавающей запятой в String, затем создать BigDecimal, вызвать метод сложения на одном из них, передать другое как аргумент, а затем преобразовать результат операции (BigDecimal) в число с плавающей запятой. Сможете ли вы выдержать такой утомительный процесс? Ниже мы предлагаем класс инструментов Arith для упрощения работы. Он предлагает следующие статические методы, включая сложение, вычитание, умножение и деление, а также округление:
Публичное статическое двойное сложение (двойное v1, двойное v2)
Публичный статический двойной субтитр (двойной V1, Double V2)
Публичный статический двойной MUL (двойной V1, Double V2)
Публичный статический двойной дивизион (двойной v1, двойной v2)
Публичный статический двойной дивизион (двойной V1, двойной V2, INT шкала)
Публичный статический двойной раунд (двойной V, Int)
Приложение
Исходный файл Arith.java:
import java.math.BigDecimal;
/**
* Поскольку простые типы Java не могут точно выполнять операции с плавающей запятой, этот класс инструмента предоставляет fines
* Точные операции с плавающей точкой, включая сложение, вычитание, умножение, деление и округление.
*/
публичный класс Ариф{
Стандартная точность деления
частный статический финальный интеллект DEF_DIV_SCALE = 10;
Этот класс нельзя инстанцировать
private Arith(){
}
/**
* Обеспечивает точные операции сложения.
* @param добавлена версия 1
* @param добавление v2
* @return Сумма двух параметров
*/
Публичное статическое двойное добавление (Double V1,Double V2){
BigDecimal b1 = новая BigDecimal(Double.toString(v1));
BigDecimal b2 = новая BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Обеспечивает точные операции вычитания.
* @param v1 вычитается
* @param v2 минус
* @return Разница между этими двумя параметрами
*/
Публичный статический двойной саб (Double V1,Double V2){
BigDecimal b1 = новая BigDecimal(Double.toString(v1));
BigDecimal b2 = новая BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* Обеспечивает точные операции умножения.
* @param v1 умножается
* @param множитель v2
* @return Произведение двух параметров
*/
Публичный статический двойной mul(double v1,double v2){
BigDecimal b1 = новая BigDecimal(Double.toString(v1));
BigDecimal b2 = новая BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* Обеспечивает (относительно) точные операции деления при неисчерпаемом делении
* 10 знаков после запятой и следующие цифры округлены.
* @param v1 делится
* @param v2 divisor
* @return Фактор двух параметров
*/
Публичный статический двойной div(двойной v1,двойной v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* Обеспечивает (относительно) точные операции разделения. Когда возникает неисчерпаемая ситуация, она указывается параметром масштаба
* Определите точность, и числа после неё будут округлены.
* @param v1 делится
* @param v2 divisor
* @param шкала указывает на то, что она должна быть точной в нескольких знаках после запятой.
* @return Фактор двух параметров
*/
Публичный статический двойной дивизион (двойной v1, двойной v2,int scale){
if(scale<0){
Добавить новое IllegalArgumentException(
«Шкала должна быть положительным целым или нулем»);
}
BigDecimal b1 = новая BigDecimal(Double.toString(v1));
BigDecimal b2 = новая BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Обеспечивает точное запятичное округление.
* @param v требует округления чисел
* @param шкала резервируется после запятой
* @return Округлённые результаты
*/
Публичный статический двойной раунд(двойной v, int scale){
if(scale<0){
Добавить новое IllegalArgumentException(
«Шкала должна быть положительным целым или нулем»);
}
BigDecimal b = новая BigDecimal(Double.toString(v));
BigDecimal один = новый BigDecimal("1");
return b.divide(one, scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}; |
Предыдущий:Лучше не ставить строку с значением в качестве первичного тональностиСледующий:Различия и связи JDK, JRE, JVM
|
