Java BigInteger Class

Ano ang isang BigInteger Class?

Mayroong ilang mga primitive na uri ng data sa Java na ginagamit, gaya ng int o long, upang magsagawa ng mga operasyong integer. Gayunpaman, kung minsan kailangan nating mag-imbak ng malalaking numero sa labas ng saklaw ng naturang mga primitive na uri ng data. Ang BigInteger Class ay ginagamit para sa mathematical computations para sa napakalaking numero. Nagbibigay ito ng lahat ng pamamaraan mula sa java.lang.Math package at mga analogue sa lahat ng primitive integer operator ng Java. BigIntegerSaklaw ng klase ang mga operasyon para sa modular arithmetic, pagmamanipula ng bit, pagkalkula ng GCD, at ilang iba pang operasyon. Ang mga BigInteger ay kinakatawan sa two's-complement notation. Walang teoretikal na limitasyon sa kung gaano kalaki ang isang numero na maaaring maimbak dahil ang memorya ay inilalaan nang pabago-bago. Gayunpaman, halos limitado ang memorya at maaari tayong mag-imbak ng isang integer na may bilang ng mga bit na mas mababa sa o katumbas ng Integer.MAX_VALUE . Nagbibigay ito ng sapat na malaking upper bound upang mag-imbak ng halos lahat ng malalaking numero.

Paano Ipinapatupad ang BigInteger Class?

import java.math.BigInteger;

Upang ipatupad ang klase ng BigInteger sa iyong code, kailangan mong mag-import ng java.math.BigInteger package.

BigInteger Class Declaration

Ang klase ng BigInteger sa Java ay idineklara sa sumusunod na paraan sa java.math package:

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

Pinapalawak ng klase ng BigInteger ang klase ng Numero at nagpapatupad ng Maihahambing na interface. Ito ay idineklara at tinukoy sa java.math package.

Mga Tagabuo ng Klase

Ang BigInteger Class ng Java ay may maraming overloaded na mga konstruktor. Maaari mong subukan at patakbuhin ang bawat isa sa editor upang makita kung paano gumagana ang mga ito.

Mga Paraan ng Klase

Ang klase ng BigInteger ng Java ay may maraming mga pamamaraan, ang ilan ay inilalarawan sa ibaba. Sa talahanayan, ang 'ito' ay kumakatawan sa BigInteger na tumatawag sa pamamaraan at ang ' val ' ay ang argumentong ipinasa sa pamamaraan.

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

Output

Paliwanag

Sa snippet sa itaas, ang factor ng isang malaking bilang ay kinakalkula gamit ang BigInteger Class sa pamamagitan ng pag-import ng java.math.BigInteger package. Gumawa kami ng isang kalkulasyon ng Factorial na pamamaraan. Lumilikha ang paraang ito ng BigInteger at pagkatapos ay kinakalkula ang factorial sa pamamagitan ng paggamit ng multiply method f.multiply(BigInteger.valueOf(i)) .

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

Output

Paliwanag

Sa snippet sa itaas, gumawa kami ng dalawang BigInteger s gamit ang BigInteger(String val) constructor. Naglapat kami ng iba't ibang pamamaraan sa BigInteger 's big1 at big2 na may mga value na 20 at 60 ayon sa pagkakabanggit. Inilapat namin ang mga sumusunod na pamamaraan:

1. big2.subtract(big1) para ibawas ang 20 sa 60.
2. big1.add(big2) para magdagdag ng 20 at 60.
3. big1.multiply(big2) para i-multiply ang 20 at 60.
4. big2.divide(big1) para hatiin ang 60 sa 20.
5. big1.min(big2) para makuha ang mas maliit sa dalawang value.
6. big1.max(big2) para makuha ang mas malaki sa dalawang value.

Mahalagang tandaan na ang java.math.BigInteger ay na-import sa tuktok ng code.

Konklusyon

Sa ngayon dapat ay pamilyar ka sa BigInteger Class sa Java. Dapat mong gamitin ang BigInteger sa iyong code gamit ang iba't ibang uri ng mga constructor. Dapat mo ring magawa ang iba't ibang aritmetika at lohikal na operasyon sa mga ito sa pamamagitan ng paggamit ng mga pamamaraan ng BigInteger Class. Bilang isang hamon, maaari mong subukang tumawag sa iba't ibang pamamaraan na may iba't ibang halaga ng BigInteger s. Lalong palalakasin nito ang iyong pag-unawa sa BigInteger sa Java. Upang maging mas kumpiyansa sa iyong pag-aaral subukang pagsasanay ito nang paulit-ulit. Ang susi sa mahusay na coding ay pagsasanay. Best of luck at maligayang coding!