Java Language
BigInteger

Introduction

Syntaxe

• BigInteger nom_variable = nouveau BigInteger ("12345678901234567890"); // un entier décimal sous forme de chaîne
• BigInteger nom_variable = new BigInteger ("1010101101010100101010011000110011101011000111110000101011010010", 2) // un entier binaire sous forme de chaîne
• BigInteger nom_variable = new BigInteger ("ab54a98ceb1f0800", 16) // un entier hexadécimal sous forme de chaîne
• BigInteger variable_name = new BigInteger (64, nouveau Random ()); // un générateur de nombres pseudo-aléatoires fournissant 64 bits pour construire un entier
• BigInteger nom_variable = nouveau BigInteger (nouvel octet [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // représentation du complément à deux signé d'un entier (big endian)
• BigInteger nom_variable = nouveau BigInteger (1, nouvel octet [] {- ​​85, 84, -87, -116, -21, 31, 10, -46}); // la représentation du complément à deux unsigned d'un entier positif (big endian)

Remarques

BigInteger sum = BigInteger.ZERO;
for(int i = 1; i < 5000; i++) {
   sum.add(BigInteger.valueOf(i));  
}

sum = sum.add(BigInteger.valueOf(i));

Initialisation

La classe java.math.BigInteger fournit des opérations analogues à tous les opérateurs entiers primitifs de Java et à toutes les méthodes pertinentes de java.lang.Math . Comme le package java.math n'est pas automatiquement disponible, vous devrez peut-être importer java.math.BigInteger avant de pouvoir utiliser le nom de classe simple.

Pour convertir long valeurs long ou int en BigInteger utilisez:

long longValue = Long.MAX_VALUE;
BigInteger valueFromLong = BigInteger.valueOf(longValue); 

ou, pour les entiers:

int intValue = Integer.MIN_VALUE; // negative
BigInteger valueFromInt = BigInteger.valueOf(intValue);

ce qui élargira le intValue entier intValue à long, en utilisant l'extension de bit de signe pour les valeurs négatives, afin que les valeurs négatives restent négatives.

Pour convertir une String numérique en BigInteger utilisez:

String decimalString = "-1";
BigInteger valueFromDecimalString = new BigInteger(decimalString);

Le constructeur suivant est utilisé pour traduire la représentation sous forme de chaîne d’un BigInteger dans la base spécifiée dans un BigInteger .

String binaryString = "10";
int binaryRadix = 2;
BigInteger valueFromBinaryString = new BigInteger(binaryString , binaryRadix);

Java prend également en charge la conversion directe des octets en une instance de BigInteger . Actuellement, seul le big endian signé et signé peut être utilisé:

byte[] bytes = new byte[] { (byte) 0x80 }; 
BigInteger valueFromBytes = new BigInteger(bytes);

Cela va générer une instance BigInteger avec la valeur -128 car le premier bit est interprété comme le bit de signe.

byte[] unsignedBytes = new byte[] { (byte) 0x80 };
int sign = 1; // positive
BigInteger valueFromUnsignedBytes = new BigInteger(sign, unsignedBytes);

Cela générera une instance BigInteger avec la valeur 128 car les octets sont interprétés comme un nombre non signé et le signe est explicitement défini sur 1, un nombre positif.

Il existe des constantes prédéfinies pour les valeurs communes:

• BigInteger.ZERO - valeur de "0".
• BigInteger.ONE - valeur de "1".
• BigInteger.TEN - valeur de "10".

Il y a aussi BigInteger.TWO (valeur de "2"), mais vous ne pouvez pas l'utiliser dans votre code car il est private .

Comparer les BigIntegers

Vous pouvez comparer BigIntegers même manière que vous comparez String ou d'autres objets en Java.

Par exemple:

BigInteger one = BigInteger.valueOf(1);
BigInteger two = BigInteger.valueOf(2);

if(one.equals(two)){
    System.out.println("Equal");
}
else{
    System.out.println("Not Equal");
}

Sortie:

Not Equal

Remarque:

En général, n'utilisez pas l'opérateur == pour comparer BigIntegers

• == opérateur: compare les références; c'est-à-dire si deux valeurs se réfèrent au même objet
• méthode equals() : compare le contenu de deux BigIntegers.

Par exemple, BigIntegers ne doit pas être comparé de la manière suivante:

if (firstBigInteger == secondBigInteger) {
  // Only checks for reference equality, not content equality!
}

Cela peut entraîner un comportement inattendu, car l'opérateur == ne vérifie que l'égalité de référence. Si les deux BigIntegers contiennent le même contenu, mais ne font pas référence au même objet, cela échouera. Au lieu de cela, comparez BigIntegers en utilisant les méthodes equals , comme expliqué ci-dessus.

Vous pouvez également comparer votre BigInteger à des valeurs constantes telles que 0,1,10.

par exemple:

BigInteger reallyBig = BigInteger.valueOf(1);
if(BigInteger.ONE.equals(reallyBig)){
    //code when they are equal.
}    

Vous pouvez également comparer deux BigIntegers en utilisant la méthode compareTo() , comme suit: compareTo() renvoie 3 valeurs.

• 0: quand les deux sont égaux .
• 1: Lorsque le premier est supérieur à la seconde (celui entre parenthèses).
• -1: Quand le premier est inférieur à la seconde.

BigInteger reallyBig = BigInteger.valueOf(10);
BigInteger reallyBig1 = BigInteger.valueOf(100);

if(reallyBig.compareTo(reallyBig1) == 0){
    //code when both are equal.
}
else if(reallyBig.compareTo(reallyBig1) == 1){
    //code when reallyBig is greater than reallyBig1.
}
else if(reallyBig.compareTo(reallyBig1) == -1){
    //code when reallyBig is less than reallyBig1.
}

Exemples d'opérations mathématiques BigInteger

BigInteger se trouve dans un objet immuable, vous devez donc affecter les résultats de toute opération mathématique à une nouvelle instance de BigInteger.

Ajout: 10 + 10 = 20

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("10");

BigInteger sum = value1.add(value2);
System.out.println(sum);

sortie: 20

Substraction: 10 - 9 = 1

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("9");

BigInteger sub = value1.subtract(value2);
System.out.println(sub);

sortie: 1

Division: 10/5 = 2

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger div = value1.divide(value2);
System.out.println(div);

sortie: 2

Division: 17/4 = 4

BigInteger value1 = new BigInteger("17");
BigInteger value2 = new BigInteger("4");

BigInteger div = value1.divide(value2);
System.out.println(div);

sortie: 4

Multiplication: 10 * 5 = 50

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger mul = value1.multiply(value2);
System.out.println(mul);

sortie: 50

Puissance: 10 ^ 3 = 1000

BigInteger value1 = new BigInteger("10");
BigInteger power = value1.pow(3);
System.out.println(power);

sortie: 1000

Reste: 10% 6 = 4

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("6");

BigInteger power = value1.remainder(value2);
System.out.println(power);

sortie: 4

GCD: Greatest Common Divisor (GCD) pour 12 et 18 est 6 .

BigInteger value1 = new BigInteger("12");
BigInteger value2 = new BigInteger("18");

System.out.println(value1.gcd(value2));

Sortie: 6

Maximum de deux BigIntegers:

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.max(value2));

Sortie: 11

Minimum de deux BigIntegers:

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.min(value2));

Sortie: 10

Opérations de logique binaire sur BigInteger

BigInteger prend également en charge les opérations logiques binaires disponibles pour les types Number . Comme pour toutes les opérations, elles sont implémentées en appelant une méthode.

Binaire ou:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.or(val2);

Sortie: 11 (ce qui équivaut à 10 | 9 )

Binaire Et:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.and(val2);

Sortie: 8 (ce qui équivaut à 10 & 9 )

Binaire Xor:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.xor(val2);

Sortie: 3 (ce qui équivaut à 10 ^ 9 )

RightShift:

BigInteger val1 = new BigInteger("10");

val1.shiftRight(1);   // the argument be an Integer    

Sortie: 5 (équivalent à 10 >> 1 )

Décalage à gauche:

BigInteger val1 = new BigInteger("10");

val1.shiftLeft(1);   // here parameter should be Integer    

Sortie: 20 (équivalent à 10 << 1 )

Inversion binaire (non):

BigInteger val1 = new BigInteger("10");

val1.not();

Sortie: 5

NAND (And-Not): *

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.andNot(val2);

Sortie: 7

Générer des BigIntegers aléatoires

La classe BigInteger possède un constructeur dédié à la génération aléatoire de BigIntegers , à partir d'une instance de java.util.Random et d'un int qui spécifie le nombre de bits du BigInteger . Son utilisation est assez simple - lorsque vous appelez le constructeur BigInteger(int, Random) comme ceci:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

alors vous vous retrouverez avec un BigInteger dont la valeur est comprise entre 0 (inclus) et 2 ^bitCount (exclusif).

Cela signifie également que le new BigInteger(2147483647, sourceOfRandomness) peut renvoyer tous les BigInteger positifs BigInteger suffisamment de temps.

Quelle sera la sourceOfRandomness à vous de sourceOfRandomness ? Par exemple, un new Random() est suffisant dans la plupart des cas:

new BigInteger(32, new Random());

Si vous êtes prêt à abandonner la vitesse pour obtenir des nombres aléatoires de meilleure qualité, vous pouvez utiliser un new SecureRandom () place:

import java.security.SecureRandom;

// somewhere in the code...
new BigInteger(32, new SecureRandom());

Vous pouvez même implémenter un algorithme à la volée avec une classe anonyme! Notez que le déploiement de votre propre algorithme RNG vous amènera à un caractère aléatoire de qualité médiocre . Veillez donc à toujours utiliser un algorithme qui s'avère être décent, à moins que vous ne souhaitiez que le ou les BigInteger soient prévisibles.

new BigInteger(32, new Random() {
    int seed = 0;

    @Override
    protected int next(int bits) {
        seed = ((22695477 * seed) + 1) & 2147483647; // Values shamelessly stolen from Wikipedia
        return seed;
    }
});