Classe Java BigInteger

Qu'est-ce qu'une classe BigInteger ?

Certains types de données primitifs en Java sont utilisés, tels que int ou long, pour effectuer des opérations sur des nombres entiers. Cependant, nous devons parfois stocker de grands nombres en dehors de la portée de ces types de données primitifs. La classe BigInteger est utilisée pour les calculs mathématiques pour les très grands nombres. Il fournit toutes les méthodes du package java.lang.Math et des analogues à tous les opérateurs entiers primitifs de Java. GrandEntierLa classe couvre les opérations pour l'arithmétique modulaire, la manipulation de bits, le calcul GCD et quelques autres opérations. Les BigIntegers sont représentés en notation de complément à deux. Il n'y a pas de limite théorique sur la taille d'un nombre pouvant être stocké car la mémoire est allouée dynamiquement. Cependant, pratiquement la mémoire est limitée et nous pouvons stocker un entier dont le nombre de bits est inférieur ou égal à Integer.MAX_VALUE . Cela fournit une borne supérieure suffisamment grande pour stocker pratiquement tous les grands nombres.

Comment la classe BigInteger est-elle implémentée?

import java.math.BigInteger;

Pour implémenter la classe BigInteger dans votre code, vous devez importer le package java.math.BigInteger.

Déclaration de classe BigInteger

La classe BigInteger en Java est déclarée de la manière suivante dans le package java.math :

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

La classe BigInteger étend la classe Number et implémente une interface Comparable . Il est déclaré et défini dans le package java.math.

Constructeurs de classe

La classe BigInteger de Java a de nombreux constructeurs surchargés. Vous pouvez essayer de les exécuter dans l'éditeur pour voir comment ils fonctionnent.

Méthodes de classe

La classe BigInteger de Java possède de nombreuses méthodes, dont certaines sont décrites ci-dessous. Dans le tableau, 'this' représente le BigInteger qui appelle la méthode et ' val ' est l'argument passé à la méthode.

Exemple 1

import java.math.BigInteger;
public class Example1 {
    static BigInteger calculateFactorial(int val) {
        // Initialize result
        BigInteger f = BigInteger.ONE; // Or new BigInteger("1")
        // compute factorial
        for (int i = 2; i <= val; i++) {
            f = f.multiply(BigInteger.valueOf(i));
        }

        return f;
    }

    // Driver method
    public static void main(String[] args) {
        int val = 25;
        System.out.println(calculateFactorial(val));
    }
}

Sortir

Explication

Dans l'extrait ci-dessus, le facteur d'un grand nombre est calculé à l'aide de la classe BigInteger en important le package java.math.BigInteger . Nous avons créé une méthode calculateFactorial . Cette méthode crée un BigInteger , puis calcule la factorielle à l'aide de la méthode de multiplication f.multiply(BigInteger.valueOf(i)) .

Exemple 2

import java.math.BigInteger;
public class Example2 {

    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("20");
        BigInteger big2 = new BigInteger("60");
        BigInteger sub = big2.subtract(big1);
        System.out.println(big2 + " - " + big1 + " = " + sub);
        BigInteger add = big1.add(big2);
        System.out.println(big1 + " + " + big2 + " = " + add);
        BigInteger mul = big1.multiply(big2);
        System.out.println(big1 + " * " + big2 + " = " + mul);
        BigInteger div = big2.divide(big1);
        System.out.println(big2 + " / " + big1 + " = " + div);
        BigInteger min = big1.min(big2);
        System.out.println("min value: " + min);
        BigInteger max = big1.max(big2);
        System.out.println("max value: " + max);
    }
}

Sortir

Explication

Dans l'extrait ci-dessus, nous avons créé deux BigInteger en utilisant le constructeur BigInteger(String val) . Nous avons appliqué différentes méthodes sur big1 et big2 de BigInteger avec les valeurs 20 et 60 respectivement. Nous avons appliqué les méthodes suivantes :

1. big2.subtract(big1) pour soustraire 20 de 60.
2. big1.add(big2) pour ajouter 20 et 60.
3. big1.multiply(big2) pour multiplier 20 et 60.
4. big2.divide(big1) pour diviser 60 par 20.
5. big1.min(big2) pour obtenir la plus petite des deux valeurs.
6. big1.max(big2) pour obtenir la plus grande des deux valeurs.

Il est important de noter que java.math.BigInteger est importé en haut du code.

Conclusion

Vous devriez maintenant être familiarisé avec la classe BigInteger en Java. Vous devriez pouvoir utiliser BigInteger s dans votre code en utilisant différents types de constructeurs. Vous devriez également être en mesure d'effectuer différentes opérations arithmétiques et logiques à l'aide des méthodes de la classe BigInteger . Comme défi, vous pouvez essayer d'appeler différentes méthodes avec différentes valeurs de BigInteger s. Cela renforcera encore votre compréhension de BigInteger s en Java. Pour être plus confiant dans votre apprentissage, essayez de le pratiquer encore et encore. La clé d'un bon codage est la pratique. Bonne chance et bon codage !