Oc-windows.ru

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

Java biginteger to integer

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.

Класс BigInteger на Java

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

Например, факториал 100 содержит 158 цифр, поэтому мы не можем сохранить его в любом доступном примитивном типе данных. Мы можем хранить в нем столько целых чисел, сколько захотим. Нет теоретического ограничения на верхнюю границу диапазона, потому что память распределяется динамически, но практически, поскольку память ограничена, вы можете хранить число, в котором содержится число бит Integer.MAX_VALUE, которого должно быть достаточно для хранения в основном всех больших значений.

Ниже приведен пример Java-программы, которая использует BigInteger для вычисления Factorial.

// Java-программа для поиска больших факториалов с использованием BigInteger
import java.math.BigInteger;
import java.util.Scanner;

public class Example

// Возвращает Факториал Н

static BigInteger factorial( int N)

BigInteger f = new BigInteger( «1» ); // Или BigInteger.ONE

// Умножаем f на 2, 3, . N

for ( int i = 2; i

public static void main(String args[]) throws Exception

Если нам нужно написать вышеуказанную программу на C ++, это было бы слишком большим и сложным, мы можем взглянуть на Factorial of Large Number .
Таким образом, класс BigInteger очень удобен в использовании из-за его большой библиотеки методов, и он также широко используется в конкурентном программировании.

Ниже приведен список простых утверждений в примитивной арифметике и аналогичных им выражений в терминах объектов BigInteger.

декларация

Инициализация:

И для целых чисел, доступных как строка, вы можете инициализировать их как:

Некоторые константы также определены в классе BigInteger для простоты инициализации:

Другими подобными функциями являются subtract (), multiply (), div (), remainder ()
Но все эти функции принимают BigInteger в качестве аргумента, поэтому, если мы хотим, чтобы эти операции с целыми числами или строки преобразовывали их в BigInteger, прежде чем передавать их в функции, как показано ниже:

Извлечение значения из BigInteger:

На самом деле CompareTo возвращает -1 (меньше), 0 (равно), 1 (больше) в соответствии со значениями.

Для равенства мы также можем использовать:

Методы класса BigInteger:

  1. BigInteger abs () : этот метод возвращает BigInteger, значение которого является абсолютным значением этого BigInteger.
  2. BigInteger add (BigInteger val) : этот метод возвращает BigInteger со значением (this + val).
  3. BigInteger и (BigInteger val) : этот метод возвращает BigInteger со значением (this & val).
  4. BigInteger andNot (BigInteger val) : этот метод возвращает BigInteger, значение которого (this &

val).

  • int bitCount () : Этот метод возвращает количество бит в двоичном представлении этого BigInteger, которое отличается от его знакового бита.
  • int bitLength () : Этот метод возвращает число бит в минимальном представлении этого дополнения BigInteger с двумя дополнениями, исключая знаковый бит.
  • byte byteValueExact () : Этот метод преобразует этот BigInteger в байт, проверяя потерянную информацию.
  • BigInteger clearBit (int n) : этот метод возвращает BigInteger, значение которого эквивалентно этому BigInteger с очищенным назначенным битом.
  • int compareTo (BigInteger val) : этот метод сравнивает этот BigInteger с указанным BigInteger.
  • Разделение BigInteger (BigInteger val) : этот метод возвращает BigInteger, значение которого (this / val).
  • BigInteger [] divAndRemainder (BigInteger val) : этот метод возвращает массив из двух BigInteger, содержащих (this / val), за которым следует (this% val).
  • double doubleValue () : Этот метод преобразует этот BigInteger в double.
  • boolean equals (Object x) : Этот метод сравнивает этот BigInteger с указанным объектом на равенство.
  • BigInteger flipBit (int n) : этот метод возвращает BigInteger, значение которого эквивалентно этому BigInteger с переключенным назначенным битом.
  • float floatValue () : этот метод преобразует этот BigInteger в число с плавающей точкой.
  • BigInteger gcd (BigInteger val) : этот метод возвращает BigInteger, значение которого является наибольшим общим делителем abs (this) и abs (val).
  • int getLowestSetBit () : Этот метод возвращает индекс самого правого (самого младшего) одного бита в этом BigInteger (число нулевых бит справа от самого правого одного бита).
  • int hashCode () : этот метод возвращает хеш-код для этого BigInteger.
  • int intValue () : Этот метод преобразует этот BigInteger в int.
  • int intValueExact () : Этот метод преобразует этот BigInteger в int, проверяя потерянную информацию.
  • boolean isProbablePrime (int уверенность) : этот метод возвращает true, если этот BigInteger, вероятно, является простым, false, если он определенно составной.
  • long longValue () : Этот метод преобразует этот BigInteger в long.
  • long longValueExact () : Этот метод преобразует этот BigInteger в long, проверяя потерянную информацию.
  • BigInteger max (BigInteger val) : этот метод возвращает максимум этого BigInteger и val.
  • BigInteger min (BigInteger val ) : этот метод возвращает минимум этого BigInteger и val.
  • Мод BigInteger (BigInteger m) : этот метод возвращает BigInteger, значение которого (этот мод m).
  • BigInteger modInverse (BigInteger m) : этот метод возвращает BigInteger, значение которого (this-1 mod m).
  • BigInteger modPow (показатель BigInteger, BigInteger m) : этот метод возвращает значение BigInteger, значение которого (thisexponent mod m).
  • BigInteger multiply (BigInteger val) : этот метод возвращает BigInteger, значение которого (this * val).
  • BigInteger negate () : этот метод возвращает BigInteger со значением (-this).
  • BigInteger nextProbablePrime () : этот метод возвращает первое целое число, большее, чем этот BigInteger, который, вероятно, является простым.
  • BigInteger not () : этот метод возвращает BigInteger со значением (

    this).

  • BigInteger или (BigInteger val) : этот метод возвращает BigInteger со значением (this | val).
  • BigInteger pow (int exponent) : этот метод возвращает BigInteger, значение которого (thisexponent).
  • s tatic BigInteger probablePrime (int bitLength, Random rnd) : этот метод возвращает положительный BigInteger, который, вероятно, является простым, с указанным bitLength.
  • BigInteger remainder (BigInteger val) : этот метод возвращает BigInteger, значение которого (это% val).
  • BigInteger setBit (int n) : этот метод возвращает BigInteger, значение которого эквивалентно этому BigInteger с установленным назначенным битом.
  • BigInteger shiftLeft (int n) : этот метод возвращает BigInteger, значение которого (это > n).
  • short shortValueExact () : Этот метод преобразует этот BigInteger в short, проверяя потерянную информацию.
  • int signum () : этот метод возвращает функцию signum этого BigInteger.
  • BigInteger sqrt () : этот метод возвращает целочисленный квадратный корень этого BigInteger.
  • BigInteger [] sqrtAndRemainder () : этот метод возвращает массив из двух BigInteger, содержащий целочисленный квадратный корень s из этого и его остаток this — s * s, соответственно.
  • BigInteger subtract (BigInteger val) : этот метод возвращает BigInteger, значение которого (this — val).
  • boolean testBit (int n) : этот метод возвращает true, если и только если установлен назначенный бит.
  • byte [] toByteArray () : Этот метод возвращает байтовый массив, содержащий представление двоичного дополнения этого BigInteger.
  • String toString () : этот метод возвращает десятичное строковое представление этого BigInteger.
  • String toString (int radix) : этот метод возвращает строковое представление этого BigInteger в заданном основании.
  • static BigInteger valueOf (long val) : этот метод возвращает BigInteger, значение которого равно значению указанного long.
  • BigInteger xor (BigInteger val) : этот метод возвращает BigInteger, значение которого (this ^ val).
  • SPOJ Проблемы:
    Таким образом, после вышеупомянутого знания функции класса BigInteger, мы можем легко решить многие сложные проблемы, но помните, что класс BigInteger для обработки внутренне использует массив целых чисел, операция над объектом BigIntegers выполняется не так быстро, как над примитивами, что является функцией добавления в BigIntgers. не требует постоянного времени, это занимает время, пропорциональное длине BigInteger, поэтому сложность программы будет меняться соответственно. Ниже приведены проблемы SPOJ, чтобы понять BigIntegers.

    Эта статья предоставлена Уткаршем Триведи. Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой теме

    BigDecimal and BigInteger in Java

    Last modified: July 20, 2019

    I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

    In the 9 years of running Baeldung, I’ve never, ever done a «sale».
    But. we’ve also not been through anything like this pandemic either.
    And, if making my courses more affordable for a while is going to help a company stay in business, or a developer land a new job, make rent or be able to provide for their family — then it’s well worth doing.
    Effective immediately, all Baeldung courses are 33% off their normal prices!
    You’ll find all three courses in the menu, above, or here.

    1. Overview

    In this tutorial, we will demonstrate BigDecimal and the BigInteger classes.

    We’ll describe the two data types, their characteristics, and their usage scenarios. We’ll also briefly cover the various operations using the two classes.

    2. BigDecimal

    BigDecimal represents an immutable arbitrary-precision signed decimal number. It consists of two parts:

    • Unscaled value – an arbitrary precision integer
    • Scale – a 32-bit integer representing the number of digits to the right of the decimal point

    For example, the BigDecimal 3.14 has the unscaled value of 314 and the scale of 2.

    We use BigDecimal for high-precision arithmetic. We also use it for calculations requiring control over scale and rounding off behavior. One such example is calculations involving financial transactions.

    We can create a BigDecimal object from String, character array, int, long, and BigInteger:

    We can also create BigDecimal from double:

    However, the result, in this case, is different from expected (that is 0.1). This is because:

    • the double constructor does an exact translation
    • 0.1 does not have an exact representation in double

    Therefore, we should use the String constructor instead of the double constructor.

    In addition, we can convert double and long to BigInteger using the valueOf static method:

    This method converts double to its String representation before converting to BigDecimal. In addition, it may reuse object instances.

    Hence, we should use the valueOf method in preference to the constructors.

    3. Operations on BigDecimal

    Just like the other Number classes (Integer, Long, Double etc.), BigDecimal provides operations for arithmetic and comparison operations. It also provides operations for scale manipulation, rounding and format conversion.

    It does not overload the the arithmetic (+, -, /, *) or logical (>.

    There are two classes which control rounding behavior – RoundingMode and MathContext.

    The enum RoundingMode provides eight rounding modes:

    • CEILING – rounds towards positive infinity
    • FLOOR – rounds towards negative infinity
    • UP – rounds away from zero
    • DOWN – rounds towards zero
    • HALF_UP – rounds towards “nearest neighbor” unless both neighbors are equidistant, in which case rounds up
    • HALF_DOWN – rounds towards “nearest neighbor” unless both neighbors are equidistant, in which case rounds down
    • HALF_EVEN – rounds towards the “nearest neighbor” unless both neighbors are equidistant, in which case, rounds towards the even neighbor
    • UNNECESSARY – no rounding is necessary and ArithmeticException is thrown if no exact result is possible

    HALF_EVEN rounding mode minimizes the bias due to rounding operations. It is frequently used. It is also known as the banker’s rounding.

    MathContext encapsulates both precision and rounding mode. There are few predefined MathContexts:

    • DECIMAL32 – 7 digits precision and a rounding mode of HALF_EVEN
    • DECIMAL64 – 16 digits precision and a rounding mode of HALF_EVEN
    • DECIMAL128 – 34 digits precision and a rounding mode of HALF_EVEN
    • UNLIMITED – unlimited precision arithmetic

    Using this class, we can round a BigDecimal number using specified precision and rounding behavior:

    Now, let’s examine the rounding concept using a sample calculation.

    Let’s write a method to calculate the total amount to be paid for an item given a quantity and unit price. Let’s also apply a discount rate and sales tax rate. We round the final result to cents by using the setScale method:

    Now, let’s write a unit test for this method:

    5. BigInteger

    BigInteger represents immutable arbitrary-precision integers. It is similar to the primitive integer types but allows arbitrary large values.

    It is used when integers involved are larger than the limit of long type. For example, the factorial of 50 is 30414093201713378043612608166064768844377641568960512000000000000. This value is too big for an int or long data type to handle. It can only be stored in a BigInteger variable.

    It is widely used in security and cryptography applications.

    We can create BigInteger from a byte array or String:

    In addition, we can convert a long to BigInteger using the static method valueOf:

    6. Operations on BigInteger

    Similar to int and long, BigInteger implements all the arithmetic and logical operations. But, it does not overload the operators.

    It also implements the corresponding methods from Math class: abs, min, max, pow, signum.

    We compare the value of two BigIntegers using the compareTo method:

    We perform arithmetic operations by calling the corresponding methods:

    As BigInteger is immutable, these operations do not modify the existing objects. Unlike, int and long, these operations do not overflow.

    BigInteger has the bit operations similar to int and long. But, we need to use the methods instead of operators:

    It has additional bit manipulation methods:

    BigInteger provides methods for GCD computation and modular arithmetic:

    It also has methods related to prime generation and primality testing:

    7. Conclusion

    In this quick tutorial, we explored the classes BigDecimal and BigInteger. They are useful for advanced numerical computations where the primitive integer types do not suffice.

    As usual, the full source code can be found over on GitHub.

    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:

    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

    Читать еще:  Integer compare java
    Ссылка на основную публикацию
    Adblock
    detector