Classe BigInteger en Java
Java contient des données intégrées ou primitives qui traitent du type et de la taille qu'une variable peut prendre pour effectuer des opérations mathématiques. Mais, parfois, ils ne sont pas assez capables de contenir des valeurs calculées car ils ont certaines limites.
Par exemple, un type de données long peut avoir des valeurs allant de -263 au 263-1 , capable de contenir la valeur la plus élevée parmi les types de données primitifs.
Disons que vous devez calculer une factorielle de 200 qui vous donnera 375 chiffres ou masse de la terre, qui pèsent environ 5,972 × 1024 kg , au-delà de la plage de valeurs qu'un type de données primitif peut contenir.
La classe Java BigInteger traite les très grands nombres entiers, vous permettant de stocker les valeurs entières de votre choix ; théoriquement, il n'y a pas de limite. Cependant, il est pragmatiquement limité en raison de la mémoire limitée d'un système.
Dans ce guide, nous examinerons chaque facteur autour de la Classe BigInteger en Java afin que vous puissiez comprendre facilement le sujet.
Qu'est-ce que la classe BigInteger en Java ?
BigInteger est une bibliothèque de classes conçue pour gérer les calculs impliquant de très grands nombres entiers. Il est conçu pour gérer les calculs qu'un type de données entier primitif normal ne peut pas gérer.
La classe Java BigInteger implémente une interface comparable et étend la classe Number. JavaBigInteger peut effectuer toutes les fonctionnalités telles que l'addition, la soustraction, le produit, la division et la recherche de PGCD de deux nombres.
Méthodes pour initialiser la classe BigInteger en Java ?
Il existe différentes manières d'initialiser les variables de type de données BigInteger.
Voici quelques méthodes pour faire la même chose :
- BigInteger(byte[] valeur) : Par ce constructeur, un tableau d'octets stockant l'entier encodé binaire complémentaire à 2 est passé en argument.
- BigInteger(signe int de Number, byte[] magnitudeOfNumber) : En utilisant ce constructeur, nous pouvons initialiser la variable en contournant le signe avec la magnitude de l'entier.
- BigInteger(int numberBits, Random value) : Utilisé pour générer un nombre aléatoire qui peut être compris entre zéro et power(2, numberBits) - 1 inclusivement.
- BigInteger(Valeur chaîne) : Une variable entière peut être initialisée en transmettant une forme de chaîne de l'entier à l'aide de ce constructeur.
Comment déclarer une classe BigInteger en Java ?
Comme pour le type de données entier normal, nous pouvons déclarer les variables du type de données BigInteger de la même manière.
Voici la manière comparative dont nous pouvons déclarer des variables de type entier et BigInteger :
int var1, var2;
BigInteger VAR1, VAR2; Dans l'exemple ci-dessus, nous pouvons voir que nous avons déclaré les variables de type de données BigInteger en majuscules ; il est considéré comme une bonne pratique de le faire car ce sont des instances de la classe BigInteger. Ainsi, pour le différencier avec des types de données entiers types de variables, nous le faisons.
var1 = 54;
var2 = 23;
VAR1 = BigInteger.valueVAR1 = new BigInteger("504");
VAR2 = new BigInteger("3572435378609854313"); Pour initialiser une variable en passant une chaîne en argument :
VAR1 = new BigInteger("504");
VAR2 = new BigInteger("3572435378609854313"); Pour effectuer une petite opération arithmétique :
int res = var1 + var2;
BigInteger RESULT = VAR1.add(VAR2); Méthodes proposées par la classe Java BigInteger
| S.NO | Nom de la méthode | Description |
|---|---|---|
| 1. | BigInteger abs() | Cette méthode renvoie une valeur positive (absolue) du type de données BigInteger. |
| 2. | Add BigInteger (valeur BigInteger) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur ajoutée de l'objet appelant avec la valeur de l'objet passé. |
| 3. | BigInteger et (BigInteger value) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant AND (&) au niveau du bit avec la valeur de l'objet passé. |
| 4. | BigInteger andNot(BigInteger value) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant ET (&) au niveau du bit avec la valeur de l'objet passé inversée. |
| 5. | int bitCount() | Renvoyer le nombre de bits dans la représentation du complément à deux de ce BigInteger qui diffèrent de son bit de signe. |
| 6. | int bitLength() | Renvoyer le nombre de bits sous forme de complément minimal à 2 (sans compter le bit de signe). |
| 7. | BigInteger clearBit(int n) | Renvoyer un BigInteger après avoir effacé ses bits désignés de la représentation d'origine. |
| 8. | int compareTo(BigInteger value) | Compare la valeur de l'objet appelant avec celle de la valeur passée en argument. |
| 9. | Division BigInteger(Valeur BigInteger) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant divisée par la valeur de l'objet passé. |
| 10. | BigInteger[ ] DivideAndRemainder(BigInteger value) | Renvoie deux nouveaux tableaux BigInteger, l'un contenant la valeur résultante égale à la valeur de l'objet appelant divisée par la valeur de l'objet passé et l'autre contenant la valeur résultante de 9objectValue%value). |
| 11. | double doubleValeur() | Renvoyer la valeur double après avoir converti la valeur BigInteger en double. |
| 12. | booléen égal à (Objet x) | Compare la valeur de l'objet passé avec celle de l'appel de la valeur de l'objet. |
| 13. | BigInteger flipBit(int n) | Renvoie un nouveau BigInteger avec une valeur obtenue après avoir inversé le bit désigné. |
| 14. | float floatValue() | Renvoie la valeur équivalente flottante du grand objet entier. |
| 15. | BigInteger gcd(BigInteger value) | Renvoie le plus grand diviseur commun des deux (valeur de l'objet appelant et abs(valeur)). |
| 16. | int getLowestSetBit() | Renvoie l'index du bit défini le plus bas, c'est-à-dire le bit avec la valeur =1, dans la valeur de l'objet appelant. |
| 17. | int hashCode() | Cette méthode renvoie le hashcode de la valeur de l'objet BigInteger appelant. |
| 18. | int intValeur() | Renvoie la valeur après avoir converti la valeur de l'objet BigInteger en type de données entier. |
| 19. | boolean isProbablePrime(int num) | Effectue le test de primalité et renvoie vrai, si le nombre est premier, sinon renvoie faux. |
| 20. | long LongValue() | Renvoie la valeur après avoir converti la valeur de l'objet BigInteger en un type de données long long. |
| 21. | BigInteger max(BigInteger value) | Renvoie la valeur maximale parmi les deux (valeur ou valeur de l'objet appelant). |
| 22. | BigInteger min(BigInteger val) | Renvoie la valeur minimale parmi les deux (valeur ou valeur de l'objet appelant). |
| 23. | Modification BigInteger (nombre BigInteger) | Renvoyer une valeur égale à tob(valeur de l'objet appelant)mod (nombre). |
| 24. | BigInteger modInverse(BigInteger m) | Renvoyer une valeur égale à l'inverse de (valeur de l'objet appelant)mod (nombre). |
| 25. | BigInteger modPow(BigInteger exp, BigInteger modulo) | Renvoie la valeur qui est égale à (valeur de l'objet élevée à la puissance exp) mod modulo. |
| 26. | Multiplication BigInteger (valeur BigInteger) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant multipliée par la valeur de l'objet passé. |
| 27. | BigInteger negate() | Renvoie la valeur négative de la valeur de l'objet appelant. |
| 28. | BigInteger nextProbablePrime() | Renvoie le nombre premier juste supérieur à la valeur de l'objet appelant. |
| 29. | BigInteger non() | Renvoie ~cette valeur pour l'objet appelant. |
| 30. | BigInteger ou (BigInteger value) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant au niveau du bit OU avec la valeur de l'objet passé. |
| 31. | BigInteger pow(int exp) | Renvoie la valeur qui est égale à la valeur de l'objet appelant multipliée par exp fois l'autre. |
| 32. | static BigInteger probablePrime(int bitLen, Random rand) | Renvoie le BigInteger non négatif qui sera un nombre premier de longueur bitLen. |
| 33. | BigInteger reste(BigInteger val) | Renvoie la valeur après avoir effectué l'opération modulo avec Val. |
| 34. | BigInteger setBit(int n) | Renvoie un nouveau BigInteger après avoir défini le nième indexé =1. |
| 35. | BigInteger shiftLeft(int num) | Renvoie un nombre après avoir décalé la valeur de l'objet appelant de num fois vers la gauche. |
| 36. | BigInteger shiftRight(int num) | Renvoie un nombre après avoir décalé la valeur de l'objet appelant de num fois vers la droite. |
| 37. | int signum() | Renvoie -1, 0 ou 1 en fonction du signe de la valeur de l'objet appelant. |
| 38. | Soustraction BigInteger(Valeur BigInteger) | Renvoie un nouveau BigInteger avec une valeur résultante égale à la valeur de l'objet appelant à soustraire avec la valeur de l'objet passé. |
| 39. | boolean testBit(int num) | Renvoie vrai si le nième bit d'index est défini dans la valeur de l'objet appelant. |
| 40. | byte[] toByteArray() | Renvoyer un tableau contenant le complément à 2 du bigInteger de l'objet appelant. |
| 41. | Chaîne versChaîne() | Convertit la représentation décimale en chaîne. |
| 42. | Chaîne versString(int radix) | Convertit la forme décimale en format de chaîne pour la base spécifiée. |
| 43. | static BigInteger valueOf(long val) | Renvoie un BigInteger contenant une valeur équivalente à la valeur longue passée en tant que paramètre. |
| 44. | BigInteger xor(BigInteger val) | Renvoie un nouveau BigInteger avec une valeur résultante égale à (valeur de l'objet appelant) XOR (valeur de l'objet passé). |
Exemple de code
import java.math.BigInteger;
public class Main
{
public static void main(String args[]) {
// Initializing result variable
BigInteger var1 = new BigInteger("110");
//returns the output of string to integer
BigInteger var2= new BigInteger("171");
System.out.println("Signum value for "+ var2 +" : "+ var2.signum());
//returns the next prime integer that is greater than this BigInteger.
BigInteger substract=var2.subtract(var1);
System.out.println(var2+"-"+var1+" : "+substract);
// calculates quotient after performing division of 2 values
BigInteger quot = var2.divide(var1);
System.out.print(var2 + " / " + var1+" : Quotient : "+quot);
//calculate remainder after performing division of 2 values
BigInteger remainder=var1.remainder(var2);
System.out.println("\nRemaider : "+remainder);
//returns a BigInteger whose value is ?this << val?
BigInteger leftShift = var1.shiftLeft(3);
System.out.println("Value after performing left shift : "+ leftShift );
BigInteger rightShift = var1.shiftRight(3);
System.out.println("Value after performing right shift : "+ rightShift);
}
} Sortie :
Signum value for 171 : 1
171-110 : 61
171 / 110 : Quotient : 1
Remainder : 110
Value after performing left shift : 880
Value after performing right shift : 13 Dans le code ci-dessus, nous avons effectué une fonction de conversion de chaîne en int, une fonction de soustraction, une fonction de division, etc. Ainsi, la syntaxe pour appeler chaque méthode reste la même, c'est-à-dire en utilisant le point (. ) opérateur.
En effet, Java est un langage orienté objet. Ainsi, chaque variable déclarée est un objet de types de données respectifs. Par conséquent, l'opérateur point doit être utilisé pour appeler n'importe quelle fonction membre de cette classe.
Il existe différentes méthodes pour construire un BigInteger dans un programme Java afin de l'utiliser tout au long du programme, en effectuant des opérations mathématiques.
- Grâce à des types de données primitifs
- Passer une chaîne dans un constructeur
- Initialisation à partir d'un fichier
Le programme suivant vous aidera à élucider le fonctionnement des grands nombres entiers :
import java.math.BigInteger;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
//constructing a BigInteger through constructor
BigInteger a = new BigInteger("value"); //method 1
BigInteger b = BigInteger.valueOf(268985); //method 2
BigInteger c= BigInteger.TEN ; //using constant values
//Performing the basic mathematical operations
BigInteger result1= a.add(b) ;//addition of two big integers
BigInteger result2= a.multiply(c) ;//multiplication
BigInteger result3= c.subtract(a) ; //subtraction
BigInteger result4= b.divide(c); //division
//print the results
System.out.println("" + result1 + result2 + result3 + result4);
BigInteger immute = new BigInteger ("111");
immute.multiply(new BigInteger ("210"));
//Print the result
System.out.println(immute); //result: 111
/*In java , objects of immutable class cannot be changed once they are declared. By default, string and wrapper classes are immutable */
//Mod operations
BigInteger mod1, mod2; //creating BigInteger objects
mod1 = new BigInteger("500");
mod2 = new BigInteger ("220");
//Perform the modulus
BigInteger ModResult = mod1.mod(mod2);
//Print result
System.out.println(ModResult.toString()); //output: 60
//Performing inverse mod
BigInteger InverseMod = mod1.modInverse(mod2);
//print result
System.out.println(InverseMod.toString()); //Output:
}
} Conclusion
Tout au long de cet article, nous avons présenté l'introduction de la classe Java BigInteger. Nous avons vu diverses méthodes intégrées proposées par celui-ci. Nous avons comparé la syntaxe de la classe BigInteger avec celle des types de données primitifs.
Cependant, l'implémentation interne de la classe BigInteger est basée sur des tableaux pour affecter la complexité supplémentaire de l'algorithme dans son ensemble.
