Java biginteger max value - Компьютерный справочник
Elettracompany.com

Компьютерный справочник
3 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Java biginteger max value

Как я могу проверить, приведет ли умножение двух чисел в Java к переполнению?

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

это упрощенная версия. В реальной программе a и b получены в другом месте во время выполнения. Чего я хочу достичь, так это чего-то подобного:

как вы предлагаете мне лучше всего кодировать это?

обновление: a и b всегда неотрицательны в моем сценарии.

14 ответов

Java 8 имеет Math.multiplyExact , Math.addExact etc. для интов и долго. Эти бросают unchecked ArithmeticException при переполнении.

если a и b оба положительные, то вы можете использовать:

Если вам нужно иметь дело как с положительными, так и с отрицательными числами, то это сложнее:

вот маленькая таблица, которую я взбил, чтобы проверить это, делая вид, что переполнение происходит в -10 или +10:

есть библиотеки Java, которые обеспечивают безопасные арифметические операции, которые проверяют длительное переполнение / underflow. Например, гуава х LongMath.checkedMultiply (длинный a, длинный b) возвращает товар a и b , при условии, что он не переполняется и бросает ArithmeticException Если a * b переполняет подписанный long арифметика.

вы можете использовать java.математика.BigInteger вместо этого и проверьте размер результата (не протестировали код):

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

имеет ли Java что-то вроде int.Максвеллову? Если да, то попробуйте

edit: видел долго.Массив в вопрос

украдено из jruby

UPDATE: этот код короткий и хорошо работает; однако он терпит неудачу при a = -1, b = Long.MIN_VALUE.

одно возможное улучшение:

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

Я не уверен, почему никто не смотрит на раствор, как:

выберите a, чтобы быть больше из двух чисел.

я хотел бы основываться на ответе Джона Кугельмана, не заменяя его прямым редактированием. Это работает для его тестового случая ( MIN_VALUE = -10 , MAX_VALUE = 10 ) из-за симметричности MIN_VALUE == -MAX_VALUE , что не относится к целым числам дополнения two. В действительности, MIN_VALUE == -MAX_VALUE — 1 .

при применении к true MIN_VALUE и MAX_VALUE , ответ Джона Кугельмана дает случай переполнения, когда a == -1 и b == что-нибудь еще (точка, впервые поднятая Кайлом). Вот способ исправить это:

это не общее решение для любого MIN_VALUE и MAX_VALUE , но это общее для Java Long и Integer и любое значение a и b .

Не уверен в этом «решении».

Edit: добавлено b != 0.

перед вами downvote: a * b / b не будет оптимизирован. Это будет ошибка компилятора. Я до сих пор не вижу случая, когда ошибка переполнения может быть замаскирована.

возможно, это поможет вам:

как было указано, Java 8 имеет математику.xxxExact методы, которые вызывают исключения при переполнении.

Если вы не используете Java 8 для своего проекта, вы все равно можете «заимствовать» их реализации, которые довольно компактны.

вот некоторые ссылки на эти реализации на стороннем веб-сайте, нет гарантии, останутся ли они действительными, но в любом случае вы должны быть в состоянии войти в источник JDK и посмотреть, как они делают свою магию внутри java.lang.Math класс.

вот самый простой способ, который я могу придумать

c / C ++ (long * long):

java (int * int, извините, я не нашел int64 в java):

1.сохраните результат в большом типе (int*int поместите результат в long, long*long в int64)

2.CMP result >> bits and result > > (bits-1)

BigInteger Java: работа с большими числами

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

Известно, что у всех примитивов есть одна неприятная особенность – переполнение типа, при котором выход за пределы допустимых значений приводит к некорректным вычислениям. Для этого существует специальный класс BigInteger. Java не была бы Java, если бы в ней не было отдельного класса с функциональностью и для этого случая. Рассмотрим его подробнее.

Класс BigInteger Java: описание

Как вы уже поняли, класс BigInteger служит оболочкой для больших целочисленных значений. Чтобы инкапсулировать число в объект данного типа, можно использовать одну из перегрузок его конструкторов, либо статический метод valueOf. Конструктор в качестве аргумента может принимать строку либо массив байтов. Для преобразования простых типов, представляющих целые числа, в BigInteger Java используют статический метод valueOf.

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

Java BigInteger: методы и примеры их использования

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

Разберем методы, выполняющие арифметические операции:

— add(value) – выполняет сложение значений текущего объекта, с переданным в качестве аргумента;

— subtract(subtractor) – выполняет вычитание subtractor от текущего значения;

— multiply(value) – выполняет умножение;

— divide(divider) – выполняет деление текущего значения на divider;

— pow(int arg) – возводит значение вызвавшего объекта в степень, величиной в arg;

— abs() – возвращает абсолютное значение вызвавшего объекта;

— negate() – возвращает объект BigInteger, значение которого имеет противоположный знак.

Читать еще:  Стандартная ошибка уравнения регрессии

Давайте разберем простой пример выполнения арифметической операции над двумя инкапсулированными в объект значениями:

— BigInteger val1, val2, adding, dividing, oppositeSign;

— val1 = new BigInteger(“5”);

Обратите внимание на способ создание объектов. Переменная val1 инициализировалась при помощи конструктора, принявшего строку, и хранит значение 5. val2 имеет значение 10 в результате работы статического метода valueOf. Значение переменной adding это результат сложение первых двух переменных и равно 15. Переменная dividing соответственно хранит результат вычитания. oppositeSign равен значению val1 с противоположным знаком, т. е. -5.

Заключение

Как видите, класс BigInteger Java предоставляет различные инструменты для операций над очень большими числами. При этом переполнение типов исключено, так как безопасность в Java имеет один из самых высоких приоритетов, естественно без ущерба функциональности.

How to convert BigInteger to Integer or Integer to BigInteger in java?

In this Blog post, We are going to learn How to Convert Integer/int from/to Biginteger with examples.

You can also check my previous posts on BigInteger class in java

java.math.BigInteger Class

BigInteger is a class defined in java.math package. Integer class is a wrapper of primitive type int and defined in java.lang package.

There is no automatic conversion of Biginteger to/from Integer or int. We have to write a code to do the conversion. The code is simple and straightforward.

Conversion of Integer to BigInteger to Integer is a day to day task for java programmer A few days back I have the need to convert the BigInteger to Integer in my java project.

BigInteger will be used in arbitrary precession arithmetic calculations where the result value of this calculations is out of range of values of all primitive numeric types

For Example, if we assign the below value, the compiler will not compile and throws The literal 12456878999999 of type int is out of range

In Java, Integer type stores the numerical values between the range of 2 power 31 -1 -2 power 31 because int preserved over 4 bytes.

Long type stores the numerical values between the range of 2 power 63 -1 -2 power 63. The reason is long data is over 8 bytes.

For BigInteger to Integer Conversion, If biginteger is unable to convert into Integer type, the conversion gives unexpected values and lose data about the magnitude of BigInteger and returns value with opposite sign, If Integer type, For Integers, It returns lowest 4 bytes values, for Long, it returns lowest 8 bytes values

We will see the conversion examples with explanation in below section.

Convert Integer to BigInteger object

Conversion of integer or int to BigInteger is an easy task, many ways we can do convert Integer to BigInteger in java.
Using String Conversion — First, convert Integer to String object using empty string concat or using toString() method.BigInteger provides Constructor for accepting String values.

The output of the above code execution is

This works as expected. This makes unnecessary String object creation for the conversion and it requires more CPU cycles for string conversion. This is not suggestable. We will see other approach using valueOf() method.
Using valueOf() method — BigInteger class has valueOf() static factory method which takes long value as input parameter and returns BigInteger Object whose value is equal of same specified type.

The result of the above program execution is

Covert BigInteger to Integer object:

BigInteger class has intValue() method to convert to Integer object. and the following is the syntax of the method

No parameters required
Returns — int from the BigInteger value

It is always not safe to convert BigInteger to Integer as this will gives overflow errors Maximum and Minimum Integer values are

Note- If BigInteger value is out of range of Integer values. You will see Overflow values like Negative values.
Please comment if you have any questions.

java число превышает long.max_value — как обнаружить?

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

Это дает мне -2 , в то время как я ожидал бы, что он бросит NumberFormatException .

Есть ли простой способ заставить это работать? Потому что у меня есть некоторый код, который делает умножения во вложенных блоках IF или сложения в цикле, и я бы не хотел добавлять больше IFs к каждому IF или внутри цикла.

Edit: Ну что ж, похоже, что этот ответ из другого вопроса является наиболее подходящим для того, что мне нужно: https://stackoverflow.com/a/9057367/540394
Я не хочу заниматься боксом/распаковкой, поскольку это добавляет ненужные накладные расходы, и этот путь очень короткий, что является огромным плюсом для меня. Я просто напишу две короткие функции, чтобы сделать эти проверки и вернуть min или max long.

Edit2: вот функция для ограничения длины до ее минимального / максимального значения в соответствии с ответом, который я связал выше:

Читать еще:  Игры на javascript

Скажите мне, если вы думаете, что это неправильно.

3 Ответа

Если вы не можете быть уверены, что результат будет меньше 9 триллионов триллионов, я бы использовал double или BigInteger получение ошибки не очень помогает вам, потому что вам все еще нужно знать, что делать.

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

С BigInteger вы можете сделать

С двойником можно обойтись

Примечание: использование double вместо long может привести к некоторой потере точности.

Я бы предпочел избежать необходимости в блоке ошибок в первую очередь.

Превышение максимального значения Лонга не выбрасывает исключение, вместо этого оно возвращается обратно. Если вы сделаете это:

вы заметите, что результат эквивалентен Long.MIN_VALUE.

Если вы хотите, чтобы он создавал исключение, проверьте, достигло ли оно максимального значения, и создайте исключение

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

это создает исключение, когда происходит переполнение при суммировании двух лонгов.

Вы можете найти javadoc здесь

Long значения, превышающие MAX_VALUE , не создают никаких исключений. Такие ситуации нужно проверять и обрабатывать вручную.

ALthough как @PeterLawrey предложил вам рассмотреть возможность использования double и BigInteger .

Похожие вопросы:

Как я могу получить длинное число больше, чем Long.MAX_VALUE? Я хочу, чтобы этот метод вернул true : boolean isBiggerThanMaxLong(long val) < return (val >Long.MAX_VALUE); >

Я продолжаю нажимать эту ошибку при вызове функций из Я не понимаю, что это значит, потому что это не последовательно. Я попал в это очень случайно, мой сеанс ps останавливается, и я получаю ошибку.

Мне было весело возиться с преобразованием Integer в Float, Float в Long, Long to Int, а затем я запутался в этом поведении ниже. Когда я преобразовываю строку s , представляющую Long.MAX_VALUE (63.

Ниже я пытаюсь присвоить value максимальное значение Long , а затем добавить к нему минимальное положительное значение Double . Затем я пытаюсь определить, что значение больше максимального значения.

Если он хранится в миллисекундах , то Какова дата, считываемая человеком для значения dateTime? Эпоха-четверг, 1 января 1970 года, и я имею в виду долго, как в Java году. long dateTime =.

Long имеет больше байтов , чем Float , поэтому я ожидал, что самый высокий long не может храниться точно в float. Это действительно так: System.out.println(String.format(%d, Long.MAX_VALUE)); //.

Я хочу сравнить два двойных значения следующим образом: Double doubleValue = Double.valueOf(Long.MAX_VALUE); Double doubleValue2 = Double.valueOf(Long.MAX_VALUE+1d); По-видимому, doubleValue и.

если я хочу преобразовать строку в int в java вы не знаете, есть ли у меня способ обнаружить переполнение? под этим я подразумеваю, что строковый литерал на самом деле представляет значение, которое.

Ниже приведен мой код, но оператор if не работает. int i = 0; while (true) < long l = fibonacci(i++); if (l Long.MAX_VALUE) < System.out.println(over); break; >> Как.

Я реализовал анализатор пакетов в Java. Теперь я хочу определить, являются ли захваченные пакеты вредоносными или нет. Например, как я могу обнаружить атаку DOS с помощью кода Java? Каков законный.

What is a BigInteger and how to use it in Java

A BigInteger is a data structure in Java that is used to represent very large numerical values that would otherwise not fit within a primitive data type such as an int or long. In this post, we will discuss different ways to initialize a BigInteger and how to use it to perform mathematical operations.

Why do we need BigIntegers

Sometimes primitive data types are not large enough to store calculated values. The largest primitive data type that can store integer values in Java is the 64-bit long. Given that it is a signed data type, this gives it the range from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

So we already established that BigIntegers are “Big”. But, what would we need such a data structure for. Well, there are some applications that come to mind. For example, if you are developing an application for Astronomy, trying to calculate the number of comets in a Galaxy, or trying to perform a calculation involving the 1,000,000,000,000,000,000,000 stars that exist in the universe.

Or if you are developing an application for physicists who would like to calculate the weight of a start. For example, our Sun is estimated to weigh 2 x 10 30 Kilograms. Big integers would definitely come in handy in such situations.

How to initialize a BigInteger

There are multiple ways to initialize a BigInteger in Java. The way you initialize it depend on where you get your data from. Therefore, we will explore a few options that might be useful.

Initializing a BigInteger from a primitive (byte/short/int/long)

In order to create an instance of a BigInteger from primitive data types such as a byte, short, int or a long, you will need to use the method BigInteger.valueOf(primitiveValue). Let us use try this with a simple program:

Running this program will yield the following results:

Читать еще:  Ошибка кс го d3dx9 43 dll

So what if we need to create a BigInteger with a very large value. We cannot store the very large value into a primitive first. And if we write the very large value directly into the valueOf method, we would get a compile error as the number is too large. Check the following code snippet for example:

To solve this issue, let us go to our next section

Initializing a BigInteger from a String

In order to create a BigInteger instance from a String, all you need to do is to feed the String representation of your number to the BigInteger constructor. Please check the next code snippet as an example:

Running this program will yield the following result on the console output:

Now that we are able to represent numerical numbers using Strings, we have raised the maximum number we can initialize a big integer to a number with 2147483647 digits. This is because the maximum length of a String is Integer.MAX_VALUE.

Initializing a BigInteger from a byte array

A big integer can also be intialized from a byte array. Simply feed your array to the constructor in order to get an instance of the big integer with the desired value. Please note that you need to represent your number in a big endian annotation. This means that the most significant data should come at the beginning of the array, and the least significant bits should be at the end of the array. Let us try it with an example:

The output of the program will be:

Also note that the BigInteger library assumes a two’s complement binary representation of the number. This means that you can represent negative numbers with the array, if you mark the most significant byte as negative. Our limitation here is the maximum size of the byte array, which is the same as the maximum value of an integer.

So what if your data is stored in a file, how can we read BigIntegers from a file?

Initializing a BigInteger from a file

If you decide to store the values of your very large numbers in a file, then you can easily read those numbers in Java. You can easily create a new instance of a big integer with a value read from a file using a Scanner. Let us create a file somewhere in our file system with the following content.

Now, let us read the file from Java. All we need to do to read the value is to call the method scanner.nextBigInteger()

Running this program will give us the following result.

Arithmetic operations with BigInteger

Arithmetic operations on BigIntegers are done through the functions provided by the BigInteger library. Given two big integer instances a and b, one can perform the following arithmetic operations as follows:

  • Addition (a + b): a.add(b)
  • Subtraction (a – b): a.subract(b)
  • Division (a / b): a.divide(b)
  • Multiplication (a * b): a.multiply(b)
  • Modulus (a % b): a.mod(b)
  • XOR (a ^ b): a.xor(b)

Let us try out these functions via a Java program.

Running this program will produce the following result:

Please also note that the BigInteger class has a lot of other functionalities, such as a.abs() which produces the absolute value (non-negative value) of the given number a. Or the function a.gcd(b) which finds the greatest common divisor of the two numbers.

BigIntegers are Immutable

Notice that each time you perform an arithmetic operation, a new BigInteger instance is produced. This is because already instantiated instances of BigIntegers are immutable. In other words, once you have created an instance, you cannot change the value of that instance. One can only assume that this was done by the Java creators because it was simpler to implement and less error prone, However, this also comes at the cost of memory as for each new instance, a new place in the JVM memory is reserved.

What is the maximum size of a BigInteger in Java

The officially supported range of values for Big integers is -(2 Integer.MAX_VALUE ) -1 to +(2 Integer.MAX_VALUE ) -1 . However, larger values are theoretically possible and are technically limited to the amount of memory the Java virtual machine has. You can read more about this in the official documentation.

In other words, there is official support for the given range of numbers in BigIntegers, however, you can unofficially use it for even larger numbers if you have enough computing resources for it.

Summary

In this post, we discussed different methods of creating instances of BigIntegers. We discussed why they are necessary and we discussed how to perform basic arithmetic operations on them. Finally, we discussed the limitations of BigIntegers in regards to their immutability and the maximum size of the numbers they can store.

If you liked this post, them please make sure to follow us on twitter by clicking the follow button down below

Ссылка на основную публикацию
ВсеИнструменты 220 Вольт
Adblock
detector