Nag-aalok ang Java ng espesyal na klase ng BigInteger para sa pamamahala ng napakalaking numero na mas malaki kaysa sa 64-bit na mga numero. Ang laki ng mga halaga ng integer na kayang hawakan ng klase na ito ay pinipigilan lamang ng inilalaan na memorya ng JVM. Ang BigInteger class, na nagmamana ng Number.implements ang Comparable interface. Nagbibigay ito ng mga katumbas para sa bawat Java primitive integer operator pati na rin ang bawat pamamaraan mula sa java.lang.math module. Ang nakaimbak na halaga ng BigInteger object ay hindi mababago dahil sa kawalan ng pagbabago ng klase ng BigInteger.
Halimbawa 1:
Ang sumusunod na programa ay nagbibigay ng paraan upang likhain ang BigInteger sa java at inilalapat ang aritmetika na operasyon sa ibinigay na halaga ng BigInteger.
Na-import namin ang klase ng BigInteger mula sa java math package sa loob ng programa. Pagkatapos noon, idineklara namin ang BigInteger objects na 'bigInt1' at 'bigInt2' sa main() na paraan ng java class na 'BigIntegerExample.' Susunod, sinimulan namin ang mga bagay na BigInteger na may malalaking numerong halaga sa loob ng klase ng BigInteger. Gumawa kami ng isa pang object ng BigInteger class para sa pagsasagawa ng arithmetic operation sa tinukoy na malaking integer value. Ang mga bagay ay idineklara bilang 'Pagpaparami' para sa pagpaparami ng halaga ng BinInteger at 'Dibisyon' para sa paghahati ng halaga ng BigInteger.
Pagkatapos, itinalaga namin ang 'bigInt1' kasama ang multiply() na paraan ng BigInteger sa object na 'multiply,' na kumukuha ng input na 'bigInt2.' Gayundin, tinawag namin ang division() na pamamaraan, na kumukuha ng parameter na 'bigInt2' na hahatiin sa 'bigInt1,' at nagpi-print ng mga resulta pagkatapos ng pagpapatupad.
Ang mga resulta ng pagpaparami at paghahati ng operasyon sa mga halaga ng BigInteger ay ipinapakita sa sumusunod na imahe ng output. Ito ay kung paano na-configure ang BigInteger sa java at ginagamit para sa iba't ibang mga operasyon.
Halimbawa 2:
Ang factorial computation ay isang magandang paglalarawan ng isang integer na nakakakuha ng napakalaking input. Ang BigInteger ay maaari ding gamitin upang makuha ang factorial para sa mas malalaking halaga ng integer.
Ginawa namin ang function na 'factorial' ng BigInteger class, kung saan ipinapasa ang 'num' object ng uri ng int bilang argumento upang ibalik ang factorial ng value na 'Num.' Sa loob ng 'factorial' function, nagdeklara kami ng BigInteger object na 'max_fict' kung saan tinukoy ang BigInteger value na '2'. Pagkatapos noon, nag-deploy kami ng for-loop, na mag-uulit at pagkatapos ay i-multiply ang 'max_fict' na value na may 4, 5, at hanggang sa nth value habang ginagamit ang multiply() na paraan. Ang multiply() mismo ay tinatawag na isa pang 'valueOf' na paraan, kung saan ang object na 'i' ng for-loop ay ibinigay. Ang return statement ay magbibigay ng mas malaking factorial. Susunod, naitatag namin ang pangunahing() na pamamaraan ng programa. Sinimulan namin ang object na 'Num' na may halaga at na-print ang factorial ng 'Num' mula sa factorial() na paraan.
Ang factorial value ng numerong '40' ay nagbibigay ng BigInteger na halaga tulad ng sumusunod:
Halimbawa 3:
Ang bitCount() function ng BigInteger class ay nagbibilang ng mga bit. Ang bitCount() method ay nagbibigay ng bilang ng mga bit na nasa anyo ng dalawang complement sa BigInteger na ito at iba sa sign bit. Ibinabalik ng paraang ito ang set bits kapag positibo ang value ng BigInteger. Sa kabilang banda, kung ang BigInteger ay tinukoy na may negatibong halaga, ibinabalik ng pamamaraang ito ang bilang ng mga reset bit.
Nagdeklara kami ng dalawang variable, 'b1' at 'b2' ng uri ng klase na 'BigInteger.' Tinukoy din namin ang dalawa pang variable, 'integer1' at 'integer2,' int primitive type. Kasunod ng deklarasyon, sinimulan namin ang 'b1' na may positibong BigInteger na halaga at ang 'b2' na may negatibong BigInteger na halaga. Susunod, itinalaga namin ang 'integer1' at 'integer2' na may bitCount() na pamamaraan sa mga variable ng BigInteger na 'b1' at 'b2.' Ang mga binilang na bit ay makukuha mula sa bitCount() na pamamaraan para sa tinukoy na mga halaga ng BigInteger.
Ang positibong BigInteger ay nagbibigay ng '2' na mga bit, at ang negatibong halaga ng BigInteger ay naglalabas ng '1' na halaga ng bit.
Halimbawa 4:
Ang absolute value ng large-size numerical data sa BigInteger ay maaaring matukoy sa pamamagitan ng paggamit ng abs() method ng BigInteger class. Ang paraan ng abs() ay nagbabalik ng ganap na halaga ng BigInteger.
Mayroon kaming BigInteger na klase, kung saan nagdeklara kami ng apat na variable: 'big1,' 'big2,' 'big3,' at 'big4'. Ang mga variable na 'big1' at 'big2' ay tinukoy na may positibo at negatibong mga halaga, ayon sa pagkakabanggit. Pagkatapos noon, ginamit namin ang abs() method na may 'big1' at 'big2' sa mga variable na 'big3' at 'big4'. Tandaan na ang abs() na pamamaraan ay hindi kumukuha ng anumang halaga ng input ngunit tinatawag na may mga variable na 'big1' at 'big2'. Nakukuha ng paraan ng abs() ang ganap na halaga para sa mga variable na ito ng BigInteger, at ipi-print ang mga resulta sa oras ng compilation.
Ang absolute value ng positive 432 at negative 432 value ay pareho dahil ang abs() method ay palaging nagbabalik ng positive absolute value.
Halimbawa 5:
Ang paghahambing ng mga halaga ng BigInteger ay maaaring makamit gamit ang BigInteger compareTo() na paraan. Ang BigInteger ay inihambing sa BigInteger na input bilang isang parameter sa loob ng compareTo() method. Ang return value ng compareTo() na paraan ay batay sa mga halaga ng BigInteger. Kapag pantay ang paghahambing ng halaga ng BigInteger, ibinabalik ang zero. Kung hindi, ibabalik ang '1' at '-1' sa kondisyon na ang halaga ng BigInteger ay mas malaki o mas maliit kaysa sa halaga ng BigInteger na ipinasa bilang isang argumento.
Mayroon kaming mga object na 'MyBigInt1' at 'MyBigtInt2' na deklarasyon ng klase na 'BigInteger.' Ang mga bagay na ito ay tinukoy na may parehong mga halaga ng BigInteger. Pagkatapos noon, gumawa kami ng isa pang object, 'comparevalue' kung saan tinatawag ang object na 'MyBigInt1' gamit ang compareTo() method, at ang object na 'MyBigInt2' ay ipinasa bilang argumento upang ihambing sa object na 'MyBigInt2'. Susunod, mayroon kaming if-else na pahayag kung saan nasuri namin kung ang mga resulta ng paraan ng compareTo() ay katumbas ng value na '0' o hindi.
Dahil ang parehong mga bagay sa BigInteger ay may parehong mga halaga, ang mga resulta ng compareTo() ay nagbabalik ng zero, tulad ng ipinapakita sa larawan sa ibaba.
Halimbawa 6:
Ang BigInteger flipBit(index) na paraan ay maaari ding gamitin upang i-flip sa isang partikular na bit na lokasyon sa loob ng isang BigInteger. Ang pamamaraang ito ay sinusuri (bigInt ^ (1< Ang index position ng BigInteger value na '9' ay binaligtad sa index na '2,' na naglalabas ng value na '13' sa output. Ang klase ng BigInteger ay napaka-maginhawang gamitin at kadalasang ginagamit sa mapagkumpitensyang programming dahil sa malawak nitong library ng pamamaraan. Ang BigInteger ay ginagamit para sa pagkalkula ng napakahabang numero na lampas sa kapasidad ng lahat ng kasalukuyang naa-access na primitive na uri ng data. Nagbibigay ito ng iba't ibang pamamaraan para sa modular na mga operasyon ng arithmetic. Ginawa muna namin ang BigInteger at pagkatapos ay sakop ang ilan sa mga pamamaraan nito.
Tinukoy namin ang dalawang variable ng BigInteger, 'B_val1' at 'B_val2.' Ang variable na 'B_val1' ay sinisimulan sa klase ng BigInteger, kung saan tinukoy ang halaga. Pagkatapos, itinakda namin ang variable na “B_val2” gamit ang flipBit() method, kung saan ang flipBit operation ay ginagawa sa variable na “B_value” na may index value na “2.”
Konklusyon