జావా బిగ్ఇంటిగర్

64-బిట్ సంఖ్యల కంటే ఎక్కువ ఉన్న చాలా పెద్ద సంఖ్యలను నిర్వహించడానికి Java ప్రత్యేక BigInteger తరగతిని అందిస్తుంది. ఈ తరగతి నిర్వహించగల పూర్ణాంక విలువల పరిమాణం కేవలం JVM యొక్క కేటాయించిన మెమరీ ద్వారా పరిమితం చేయబడింది. BigInteger తరగతి, ఇది ఒక సంఖ్యను వారసత్వంగా పొందుతుంది. పోల్చదగిన ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది. ఇది ప్రతి జావా ఆదిమ పూర్ణాంక ఆపరేటర్‌కు సమానమైన వాటిని అలాగే java.lang.math మాడ్యూల్ నుండి ప్రతి పద్ధతిని అందిస్తుంది. BigInteger తరగతి యొక్క మార్పులేని కారణంగా BigInteger ఆబ్జెక్ట్ నిల్వ చేయబడిన విలువ సవరించబడదు.

ఉదాహరణ 1:

కింది ప్రోగ్రామ్ జావాలో BigIntegerని సృష్టించడానికి ఒక మార్గాన్ని అందిస్తుంది మరియు అందించిన BigInteger విలువకు అంకగణిత ఆపరేషన్‌ని వర్తింపజేస్తుంది.

మేము ప్రోగ్రామ్‌లోని జావా గణిత ప్యాకేజీ నుండి BigInteger తరగతిని దిగుమతి చేసాము. ఆ తర్వాత, మేము జావా క్లాస్ “BigIntegerExample” యొక్క మెయిన్() పద్ధతిలో BigInteger ఆబ్జెక్ట్‌లను “bigInt1” మరియు “bigInt2”గా ప్రకటించాము. తరువాత, మేము BigInteger తరగతిలోని పెద్ద సంఖ్యా విలువలతో BigInteger ఆబ్జెక్ట్‌లను ప్రారంభించాము. మేము పేర్కొన్న పెద్ద పూర్ణాంకాల విలువపై అంకగణిత ఆపరేషన్‌ని నిర్వహించడానికి BigInteger తరగతి యొక్క మరొక వస్తువును సృష్టించాము. వస్తువులు BinInteger విలువను గుణించడం కోసం 'గుణకారం' మరియు BigInteger విలువను విభజించడం కోసం 'డివిజన్'గా ప్రకటించబడ్డాయి.

అప్పుడు, మేము 'bigInt2' ఇన్‌పుట్‌ని తీసుకునే ఆబ్జెక్ట్ 'మల్టిప్లై'కి BigInteger యొక్క గుణకారం() పద్ధతితో పాటుగా 'bigInt1'ని కేటాయించాము. అలాగే, మేము డివిజన్() పద్ధతిని పిలిచాము, ఇది 'bigInt2' పరామితిని తీసుకుంటుంది, ఇది 'bigInt1'తో విభజించబడుతుంది మరియు అమలు తర్వాత ఫలితాలను ముద్రిస్తుంది.

BigInteger విలువలపై గుణకారం మరియు విభజన ఆపరేషన్ ఫలితాలు క్రింది అవుట్‌పుట్ ఇమేజ్‌లో చూపబడ్డాయి. బిగ్ఇంటెజర్ జావాలో కాన్ఫిగర్ చేయబడి వివిధ కార్యకలాపాలకు ఈ విధంగా ఉపయోగించబడుతుంది.

ఉదాహరణ 2:

ఫాక్టోరియల్ గణన అనేది పూర్ణాంకం చాలా పెద్ద ఇన్‌పుట్‌లను పొందేందుకు మంచి ఉదాహరణ. పెద్ద పూర్ణాంక విలువల కోసం కారకాన్ని పొందడానికి BigIntegerని కూడా ఉపయోగించవచ్చు.

మేము BigInteger తరగతి యొక్క “కారకమైన” ఫంక్షన్‌ని సృష్టించాము, ఇక్కడ “Num” విలువ యొక్క కారకాన్ని తిరిగి ఇవ్వడానికి టైప్ int యొక్క “num” ఆబ్జెక్ట్ ఆర్గ్యుమెంట్‌గా పాస్ చేయబడుతుంది. “కారకం” ఫంక్షన్ లోపల, మేము BigInteger ఆబ్జెక్ట్ “max_fict”ని ప్రకటించాము, ఇక్కడ BigInteger విలువ “2” పేర్కొనబడింది. ఆ తర్వాత, మేము ఫర్-లూప్‌ని అమలు చేసాము, అది మళ్ళి “max_fict” విలువను 4, 5తో గుణించి, గుణకారం() పద్ధతి ప్రారంభించబడినందున nవ విలువ వరకు గుణించబడుతుంది. గుణకారం()ని మరొక 'valueOf' పద్ధతి అంటారు, ఇక్కడ for-loop యొక్క వస్తువు 'i' అందించబడుతుంది. రిటర్న్ స్టేట్‌మెంట్ పెద్ద కారకాన్ని అందిస్తుంది. తరువాత, మేము ప్రోగ్రామ్ యొక్క ప్రధాన () పద్ధతిని ఏర్పాటు చేసాము. మేము 'Num' ఆబ్జెక్ట్‌ను విలువతో ప్రారంభించాము మరియు ఫాక్టోరియల్() పద్ధతి నుండి 'Num' యొక్క కారకాన్ని ముద్రించాము.

'40' సంఖ్య యొక్క కారకం విలువ కింది విధంగా BigInteger విలువను అందిస్తుంది:

ఉదాహరణ 3:

BigInteger తరగతి యొక్క bitCount() ఫంక్షన్ బిట్‌లను గణిస్తుంది. bitCount() పద్ధతి ఈ BigIntegerలో రెండు పూరకాల రూపంలో మరియు సైన్ బిట్‌కు భిన్నంగా ఉండే బిట్‌ల సంఖ్యను అందిస్తుంది. BigInteger విలువ సానుకూలంగా ఉన్నప్పుడు ఈ పద్ధతి సెట్ బిట్‌లను అందిస్తుంది. మరోవైపు, BigInteger ప్రతికూల విలువతో పేర్కొనబడితే, ఈ పద్ధతి రీసెట్ బిట్‌ల సంఖ్యను అందిస్తుంది.

మేము 'BigInteger' రకం క్లాస్ యొక్క 'b1' మరియు 'b2' అనే రెండు వేరియబుల్‌లను ప్రకటించాము. మేము మరో రెండు వేరియబుల్స్, “integer1” మరియు “integer2,” int primitive typeని కూడా నిర్వచించాము. డిక్లరేషన్ తర్వాత, మేము పాజిటివ్ BigInteger విలువతో “b1”ని మరియు ప్రతికూల BigInteger విలువతో “b2”ని ప్రారంభించాము. తరువాత, మేము బిగ్ఇంటెజర్ వేరియబుల్స్ “b1” మరియు “b2”కి bitCount() పద్ధతితో “integer1” మరియు “integer2”ని కేటాయించాము. లెక్కించబడిన బిట్‌లు పేర్కొన్న BigInteger విలువల కోసం bitCount() పద్ధతి నుండి పొందబడతాయి.

సానుకూల BigInteger “2” బిట్‌లను అందిస్తుంది మరియు BigInteger యొక్క ప్రతికూల విలువ “1” బిట్ విలువను అందిస్తుంది.

ఉదాహరణ 4:

BigIntegerలోని పెద్ద-పరిమాణ సంఖ్యా డేటా యొక్క సంపూర్ణ విలువను BigInteger తరగతి యొక్క abs() పద్ధతిని ఉపయోగించడం ద్వారా నిర్ణయించవచ్చు. abs() పద్ధతి BigInteger యొక్క సంపూర్ణ విలువను అందిస్తుంది.

మేము ఒక BigInteger తరగతిని కలిగి ఉన్నాము, దాని నుండి మేము నాలుగు వేరియబుల్‌లను ప్రకటించాము: “big1,” “big2,” “big3,” మరియు “big4”. వేరియబుల్స్ “big1” మరియు “big2” వరుసగా ధనాత్మక మరియు ప్రతికూల విలువలతో పేర్కొనబడ్డాయి. ఆ తర్వాత, మేము 'big3' మరియు 'big4' వేరియబుల్స్‌లో 'big1' మరియు 'big2'తో abs() పద్ధతిని ప్రారంభించాము. abs() పద్ధతి ఎటువంటి ఇన్‌పుట్ విలువను తీసుకోదు కానీ 'big1' మరియు 'big2' అనే వేరియబుల్స్‌తో పిలవబడుతుంది. ఈ BigInteger వేరియబుల్స్ కోసం abs() పద్ధతి సంపూర్ణ విలువను పొందుతుంది మరియు ఫలితాలు సంకలన సమయంలో ముద్రించబడతాయి.

ధనాత్మక 432 మరియు ప్రతికూల 432 విలువల సంపూర్ణ విలువ ఒకే విధంగా ఉంటుంది ఎందుకంటే abs() పద్ధతి ఎల్లప్పుడూ సానుకూల సంపూర్ణ విలువను అందిస్తుంది.

ఉదాహరణ 5:

BigInteger compareTo() పద్ధతిని ఉపయోగించి BigInteger విలువల పోలికను సాధించవచ్చు. BigInteger, compareTo() పద్ధతిలో పారామీటర్‌గా ఇన్‌పుట్ చేయబడిన BigIntegerతో పోల్చబడింది. compareTo() పద్ధతి యొక్క రిటర్న్ విలువ BigInteger విలువలపై ఆధారపడి ఉంటుంది. BigInteger విలువ యొక్క పోలిక సమానంగా ఉన్నప్పుడు, సున్నా తిరిగి ఇవ్వబడుతుంది. లేకపోతే, BigInteger విలువ ఆర్గ్యుమెంట్‌గా ఆమోదించబడిన BigInteger విలువ కంటే ఎక్కువ లేదా చిన్నది అనే షరతుపై “1” మరియు “-1” అందించబడతాయి.

'BigInteger' క్లాస్ యొక్క 'MyBigInt1' మరియు 'MyBigtInt2' డిక్లరేషన్ ఆబ్జెక్ట్‌లను కలిగి ఉన్నాము. ఈ వస్తువులు అదే BigInteger విలువలతో పేర్కొనబడతాయి. ఆ తర్వాత, 'MyBigInt1' ఆబ్జెక్ట్‌ను compareTo() పద్ధతితో పిలవబడే 'comparevalue' అనే మరొక ఆబ్జెక్ట్‌ని మేము సృష్టించాము మరియు 'MyBigInt2' ఆబ్జెక్ట్‌ను 'MyBigInt2' ఆబ్జెక్ట్‌తో పోల్చడానికి ఆర్గ్యుమెంట్‌గా పాస్ చేయబడింది. తర్వాత, compareTo() పద్ధతి యొక్క ఫలితాలు “0” విలువకు సమానంగా ఉన్నాయా లేదా అని మేము తనిఖీ చేసిన if-else స్టేట్‌మెంట్‌ని కలిగి ఉన్నాము.

రెండు BigInteger ఆబ్జెక్ట్‌లు ఒకే విలువలను కలిగి ఉన్నందున, దిగువ చిత్రంలో చూపిన విధంగా compareTo() ఫలితాలు సున్నాని అందిస్తాయి.

ఉదాహరణ 6:

BigInteger flipBit(index) పద్ధతిని BigIntegerలో నిర్దిష్ట బిట్ లొకేషన్‌లో తిప్పడానికి కూడా ఉపయోగించవచ్చు. ఈ పద్ధతి మూల్యాంకనం చేస్తుంది (bigInt ^ (1<

మేము రెండు BigInteger వేరియబుల్స్, “B_val1” మరియు “B_val2”ని నిర్వచించాము. 'B_val1' వేరియబుల్ BigInteger తరగతితో ప్రారంభించబడింది, ఇక్కడ విలువ పేర్కొనబడింది. అప్పుడు, మేము flipBit() పద్ధతితో వేరియబుల్ “B_val2”ని సెట్ చేసాము, ఇక్కడ flipBit ఆపరేషన్ ఇండెక్స్ విలువ “2”తో వేరియబుల్ “B_value”పై నిర్వహించబడుతుంది.

BigInteger విలువ '9' యొక్క సూచిక స్థానం '2' సూచికతో తిప్పబడింది, ఇది అవుట్‌పుట్‌లో '13' విలువను అవుట్‌పుట్ చేస్తుంది.

ముగింపు

BigInteger క్లాస్ ఉపయోగించడానికి చాలా సౌకర్యవంతంగా ఉంటుంది మరియు దాని విస్తారమైన మెథడ్ లైబ్రరీ కారణంగా పోటీ ప్రోగ్రామింగ్‌లో తరచుగా ఉపయోగించబడుతుంది. BigInteger అనేది ప్రస్తుతం అందుబాటులో ఉన్న అన్ని ఆదిమ డేటా రకాల సామర్థ్యానికి మించిన చాలా పెద్ద సంఖ్యల గణన కోసం ఉపయోగించబడుతుంది. ఇది మాడ్యులర్ అంకగణిత కార్యకలాపాలకు వివిధ పద్ధతులను అందిస్తుంది. మేము ముందుగా BigIntegerని సృష్టించాము మరియు దానిలోని కొన్ని పద్ధతులను కవర్ చేసాము.