Java BigInteger-klasse

Wat is een BigInteger-klasse?

Er zijn enkele primitieve gegevenstypen in Java die worden gebruikt, zoals int of long, om integer-bewerkingen uit te voeren. Soms moeten we echter grote aantallen opslaan buiten het bereik van dergelijke primitieve gegevenstypen. BigInteger Class wordt gebruikt voor wiskundige berekeningen voor zeer grote getallen. Het biedt alle methoden van het java.lang.Math- pakket en analogen voor alle primitieve integer-operators van Java. BigIntegerKlasse omvat bewerkingen voor modulair rekenen, bitmanipulatie, GCD-berekening en enkele andere bewerkingen. BigIntegers worden weergegeven in twee-complementnotatie. Er is geen theoretische limiet aan hoe groot een getal kan worden opgeslagen, omdat het geheugen dynamisch wordt toegewezen. Het geheugen is echter praktisch beperkt en we kunnen een geheel getal opslaan met een aantal bits dat kleiner is dan of gelijk is aan de Integer.MAX_VALUE . Dit levert een voldoende grote bovengrens op om vrijwel alle grote getallen op te slaan.

Hoe wordt de BigInteger-klasse geïmplementeerd?

import java.math.BigInteger;

Om de BigInteger- klasse in uw code te implementeren, moet u het java.math.BigInteger- pakket importeren .

BigInteger-klasseverklaring

De klasse BigInteger in Java wordt op de volgende manier gedeclareerd in het pakket java.math :

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

De klasse BigInteger breidt de klasse Number uit en implementeert een vergelijkbare interface. Het wordt gedeclareerd en gedefinieerd in het java.math- pakket.

Klasse constructeurs

De BigInteger- klasse van Java heeft veel overbelaste constructors. U kunt proberen ze allemaal in de editor uit te voeren om te zien hoe ze werken.

Klasse methoden

De BigInteger- klasse van Java heeft veel methoden, waarvan er enkele hieronder worden beschreven. In de tabel staat 'this' voor de BigInteger die de methode aanroept en ' val ' is het argument dat aan de methode wordt doorgegeven.

voorbeeld 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));
    }
}

Uitgang

Uitleg

In het bovenstaande fragment wordt de factor van een groot getal berekend met BigInteger Class door het java.math.BigInteger- pakket te importeren. We hebben een methodecalculFactorial gemaakt . Deze methode maakt een BigInteger en berekent vervolgens de faculteit met behulp van de vermenigvuldigingsmethode f.multiply(BigInteger.valueOf(i)) .

Voorbeeld 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);
    }
}

Uitgang

Uitleg

In het fragment hierboven hebben we twee BigInteger s gemaakt met behulp van de BigInteger(String val) constructor. We hebben verschillende methoden toegepast op de Big1 en big2 van de BigInteger met respectievelijk de waarden 20 en 60. We hebben de volgende methodes toegepast:

1. big2.subtract(big1) om 20 van 60 af te trekken.
2. big1.add(big2) om 20 en 60 op te tellen.
3. big1.multiply(big2) om 20 en 60 te vermenigvuldigen.
4. big2.divide(big1) om 60 te delen door 20.
5. big1.min(big2) om de kleinste van de twee waarden te krijgen.
6. big1.max(big2) om de grootste van de twee waarden te krijgen.

Het is belangrijk op te merken dat java.math.BigInteger bovenaan de code wordt geïmporteerd.

Conclusie

U zou nu bekend moeten zijn met de BigInteger- klasse in Java. U zou BigInteger s in uw code moeten kunnen gebruiken met behulp van verschillende soorten constructors. U zou er ook verschillende rekenkundige en logische bewerkingen op moeten kunnen uitvoeren door BigInteger Class-methoden te gebruiken. Als uitdaging kunt u proberen verschillende methoden aan te roepen met verschillende waarden van BigInteger s. Het zal uw begrip van BigInteger s in Java verder versterken. Probeer het steeds opnieuw te oefenen om meer vertrouwen te krijgen in uw leren. De sleutel tot goed coderen is oefenen. Veel succes en veel codeerplezier!