Java Language
BigInteger

परिचय

वाक्य - विन्यास

• BigInteger variable_name = नया BigInteger ("12345678901234567890"); // एक स्ट्रिंग के रूप में एक दशमलव पूर्णांक
• BigInteger variable_name = नया BigInteger ("10101011010101010101001100011001101010111110000010101000010", 2) // एक स्ट्रिंग के रूप में एक बाइनरी पूर्णांक
• BigInteger variable_name = नया BigInteger ("ab54a98ceb1f0800", 16) // एक स्ट्रिंग के रूप में एक हेक्साडेसिमल पूर्णांक
• BigInteger variable_name = नया BigInteger (64, नया रैंडम ()); // पूर्णांक बनाने के लिए 64 बिट्स की आपूर्ति करने वाला एक छद्म आयामी संख्या जनरेटर
• BigInteger variable_name = नया BigInteger (नया बाइट [] {0, -85, 84, -87, -116, -21, 31, 10, -46}); // पूर्णांक के दो पूरक प्रतिनिधित्व पर हस्ताक्षर किए (बड़ा एंडियन)
• BigInteger variable_name = नया BigInteger (1, नया बाइट [] {- 85, 84, -87, -116, -21, 31, 10, -46}); // अहस्ताक्षरित दो पूर्णांक एक सकारात्मक पूर्णांक का प्रतिनिधित्व (बड़ा एंडियन)

टिप्पणियों

BigInteger sum = BigInteger.ZERO;
for(int i = 1; i < 5000; i++) {
   sum.add(BigInteger.valueOf(i));  
}

sum = sum.add(BigInteger.valueOf(i));

प्रारंभ

java.math.BigInteger वर्ग जावा के सभी आदिम पूर्णांक संचालकों के लिए और java.lang.Math सभी प्रासंगिक तरीकों के लिए प्रचालन एनालॉग प्रदान करता है। चूंकि java.math पैकेज स्वचालित रूप से उपलब्ध नहीं है, इसलिए आपको साधारण वर्ग के नाम का उपयोग करने से पहले java.math.BigInteger आयात करना पड़ सकता है।

BigInteger उपयोग के लिए long या int मानों को परिवर्तित करने के लिए:

long longValue = Long.MAX_VALUE;
BigInteger valueFromLong = BigInteger.valueOf(longValue); 

या, पूर्णांकों के लिए:

int intValue = Integer.MIN_VALUE; // negative
BigInteger valueFromInt = BigInteger.valueOf(intValue);

जो नकारात्मक मानों के लिए साइन बिट एक्सटेंशन का उपयोग करके लंबे समय तक intValue पूर्णांक को चौड़ा करेगा, ताकि नकारात्मक मान नकारात्मक रहें।

एक संख्यात्मक String को BigInteger उपयोग में बदलने के लिए:

String decimalString = "-1";
BigInteger valueFromDecimalString = new BigInteger(decimalString);

निर्माता के बाद एक की स्ट्रिंग प्रतिनिधित्व अनुवाद करने के लिए प्रयोग किया जाता है BigInteger एक में निर्दिष्ट मूलांक में BigInteger ।

String binaryString = "10";
int binaryRadix = 2;
BigInteger valueFromBinaryString = new BigInteger(binaryString , binaryRadix);

जावा BigInteger एक उदाहरण के लिए बाइट्स के प्रत्यक्ष रूपांतरण का भी समर्थन करता है। वर्तमान में केवल हस्ताक्षरित और अहस्ताक्षरित बड़े एंडियन एन्कोडिंग का उपयोग किया जा सकता है:

byte[] bytes = new byte[] { (byte) 0x80 }; 
BigInteger valueFromBytes = new BigInteger(bytes);

यह BigInteger उदाहरण -128 के साथ उत्पन्न करेगा क्योंकि पहले बिट को साइन बिट के रूप में व्याख्या की जाती है।

byte[] unsignedBytes = new byte[] { (byte) 0x80 };
int sign = 1; // positive
BigInteger valueFromUnsignedBytes = new BigInteger(sign, unsignedBytes);

यह मान के साथ एक BigInteger इंस्टेंस उत्पन्न करेगा 128 के रूप में बाइट्स अहस्ताक्षरित संख्या के रूप में व्याख्या कर रहे हैं, और संकेत स्पष्ट रूप से 1, एक सकारात्मक संख्या पर सेट है।

सामान्य मूल्यों के लिए पूर्वनिर्धारित स्थिरांक हैं:

• BigInteger.ZERO - "0" का मान।
• BigInteger.ONE - "1" का मूल्य।
• BigInteger.TEN - "10" का मूल्य।

इसमें BigInteger.TWO ("2" का मान) भी है, लेकिन आप इसे अपने कोड में उपयोग नहीं कर सकते क्योंकि यह private ।

BigIntegers की तुलना करना

आप BigIntegers तुलना उसी तरह कर सकते हैं जैसे आप जावा में String या अन्य वस्तुओं की तुलना करते हैं।

उदाहरण के लिए:

BigInteger one = BigInteger.valueOf(1);
BigInteger two = BigInteger.valueOf(2);

if(one.equals(two)){
    System.out.println("Equal");
}
else{
    System.out.println("Not Equal");
}

आउटपुट:

Not Equal

ध्यान दें:

सामान्य तौर पर, BigIntegers की तुलना करने के लिए == ऑपरेटर का उपयोग न करें

• == ऑपरेटर: संदर्भों की तुलना करता है; अर्थात क्या दो मान एक ही वस्तु को संदर्भित करते हैं
• equals() विधि: दो BigIntegers की सामग्री की तुलना करती है।

उदाहरण के लिए, BigIntegers की तुलना निम्नलिखित तरीके से नहीं की जानी चाहिए:

if (firstBigInteger == secondBigInteger) {
  // Only checks for reference equality, not content equality!
}

ऐसा करने से अप्रत्याशित व्यवहार हो सकता है, क्योंकि == ऑपरेटर केवल संदर्भ समानता की जांच करता है। यदि दोनों BigIntegers में समान सामग्री है, लेकिन एक ही ऑब्जेक्ट को संदर्भित नहीं करते हैं, तो यह विफल हो जाएगा। इसके बजाय, ऊपर बताए अनुसार, equals विधियों का उपयोग करके BigIntegers की तुलना करें।

आप अपने BigInteger तुलना 0,1,10 जैसे निरंतर मूल्यों से भी कर सकते हैं।

उदाहरण के लिए:

BigInteger reallyBig = BigInteger.valueOf(1);
if(BigInteger.ONE.equals(reallyBig)){
    //code when they are equal.
}    

आप दो BigIntegers की तुलना compareTo() विधि का उपयोग करके भी कर सकते हैं, जैसा कि निम्नलिखित: compareTo() 3 मान देता है।

• 0: जब दोनों समान हों ।
• 1: जब प्रथम, द्वितीय (कोष्ठक में से एक) से अधिक है।
• -1: जब पहला सेकंड से कम हो ।

BigInteger reallyBig = BigInteger.valueOf(10);
BigInteger reallyBig1 = BigInteger.valueOf(100);

if(reallyBig.compareTo(reallyBig1) == 0){
    //code when both are equal.
}
else if(reallyBig.compareTo(reallyBig1) == 1){
    //code when reallyBig is greater than reallyBig1.
}
else if(reallyBig.compareTo(reallyBig1) == -1){
    //code when reallyBig is less than reallyBig1.
}

BigInteger गणितीय संचालन उदाहरण

BigInteger एक अपरिवर्तनीय वस्तु में है, इसलिए आपको किसी भी गणितीय ऑपरेशन के परिणामों को नए BigInteger उदाहरण में निर्दिष्ट करने की आवश्यकता है।

जोड़: 10 + 10 = 20

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("10");

BigInteger sum = value1.add(value2);
System.out.println(sum);

आउटपुट: 20

पदार्थ: 10 - 9 = 1

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("9");

BigInteger sub = value1.subtract(value2);
System.out.println(sub);

आउटपुट: 1

प्रभाग: 10/5 = 2

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger div = value1.divide(value2);
System.out.println(div);

आउटपुट: २

प्रभाग: 17/4 = 4

BigInteger value1 = new BigInteger("17");
BigInteger value2 = new BigInteger("4");

BigInteger div = value1.divide(value2);
System.out.println(div);

आउटपुट: 4

गुणन: 10 * 5 = 50

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("5");

BigInteger mul = value1.multiply(value2);
System.out.println(mul);

आउटपुट: 50

पावर: 10 ^ 3 = 1000

BigInteger value1 = new BigInteger("10");
BigInteger power = value1.pow(3);
System.out.println(power);

आउटपुट: 1000

शेष: 10% 6 = 4

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("6");

BigInteger power = value1.remainder(value2);
System.out.println(power);

आउटपुट: 4

GCD: 12 और 18 लिए सबसे बड़ा कॉमन डिविज़र (GCD) 6 ।

BigInteger value1 = new BigInteger("12");
BigInteger value2 = new BigInteger("18");

System.out.println(value1.gcd(value2));

आउटपुट: 6

अधिकतम दो बिगइंटर:

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.max(value2));

आउटपुट: 11

दो BigIntegers की न्यूनतम :

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.min(value2));

आउटपुट: १०

BigInteger पर बाइनरी लॉजिक ऑपरेशंस

BigInteger बाइनरी लॉजिक ऑपरेशंस को सपोर्ट करता है जो कि Number प्रकारों के लिए भी उपलब्ध हैं। जैसा कि सभी ऑपरेशनों के साथ होता है, उन्हें एक विधि कहकर कार्यान्वित किया जाता है।

बाइनरी या:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.or(val2);

आउटपुट: 11 (जो 10 | 9 बराबर है 10 | 9 )

बाइनरी और:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.and(val2);

आउटपुट: 8 (जो 10 & 9 बराबर है)

बाइनरी Xor:

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.xor(val2);

आउटपुट: 3 (जो 10 ^ 9 बराबर है)

सही बदलाव:

BigInteger val1 = new BigInteger("10");

val1.shiftRight(1);   // the argument be an Integer    

आउटपुट: 5 ( 10 >> 1 बराबर)

बायां शिफ्ट:

BigInteger val1 = new BigInteger("10");

val1.shiftLeft(1);   // here parameter should be Integer    

आउटपुट: 20 ( 10 << 1 बराबर)

बाइनरी उलटा (नहीं):

BigInteger val1 = new BigInteger("10");

val1.not();

आउटपुट: 5

नंद (और-नहीं): *

BigInteger val1 = new BigInteger("10");
BigInteger val2 = new BigInteger("9");

val1.andNot(val2);

आउटपुट: 7

रैंडम BigIntegers उत्पन्न करना

BigInteger वर्ग में एक BigInteger है जो यादृच्छिक BigIntegers उत्पन्न करने के लिए समर्पित है, जिसे java.util.Random उदाहरण दिया गया है और एक int जो निर्दिष्ट करता है कि BigInteger कितने बिट्स होंगे। इसका उपयोग काफी सरल है - जब आप कंस्ट्रक्टर को BigInteger(int, Random) इस तरह कहते हैं:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

फिर आप एक BigInteger साथ समाप्त हो जाएंगे, जिसका मान 0 (समावेशी) और 2 ^bitCount (अनन्य) के बीच है।

इसका मतलब यह भी है कि new BigInteger(2147483647, sourceOfRandomness) सभी सकारात्मक BigInteger s को पर्याप्त समय new BigInteger(2147483647, sourceOfRandomness) लौटा सकते हैं।

sourceOfRandomness क्या होगा आप पर निर्भर है। उदाहरण के लिए, एक new Random() ज्यादातर मामलों में पर्याप्त है:

new BigInteger(32, new Random());

यदि आप उच्च-गुणवत्ता वाले यादृच्छिक संख्याओं के लिए गति देने को तैयार हैं, तो आप इसके बजाय एक new SecureRandom () उपयोग कर सकते हैं:

import java.security.SecureRandom;

// somewhere in the code...
new BigInteger(32, new SecureRandom());

तुम भी एक अनाम वर्ग के साथ पर एक एल्गोरिथ्म को लागू कर सकते हैं! ध्यान दें कि अपने स्वयं के आरएनजी एल्गोरिथ्म को रोल आउट करने से आप कम गुणवत्ता वाले यादृच्छिकता के साथ समाप्त हो जाएंगे , इसलिए हमेशा एक एल्गोरिथ्म का उपयोग करना सुनिश्चित करें, जो तब तक सभ्य साबित होता है जब तक कि आप परिणामी BigInteger को पूर्वानुमानित नहीं करना चाहते।

new BigInteger(32, new Random() {
    int seed = 0;

    @Override
    protected int next(int bits) {
        seed = ((22695477 * seed) + 1) & 2147483647; // Values shamelessly stolen from Wikipedia
        return seed;
    }
});