जावा में बिगडिमल

नमस्ते! आज के पाठ में हम बड़ी संख्या के बारे में बात करेंगे। नहीं, मेरा मतलब वास्तव में बड़ा है। हम पहले बार-बार आदिम डेटा प्रकारों के लिए मान श्रेणियों की तालिका का सामना कर चुके हैं। यह इस तरह दिख रहा है: सबसे बड़ा पूर्णांक डेटा प्रकार लंबा है । जब फ्लोटिंग-पॉइंट नंबरों की बात आती है, तो यह डबल होता है । लेकिन क्या होगा अगर हमें जिस संख्या की आवश्यकता है वह इतनी बड़ी है कि वह एक लंबे समय में भी फिट नहीं होती है ? लंबे डेटा प्रकार में संभावित मानों की काफी बड़ी रेंज होती है, लेकिन यह अभी भी 64 बिट्स तक सीमित है। अगर हमारी बहुत बड़ी संख्या के लिए 100 बिट्स की आवश्यकता है तो हमें क्या करने की आवश्यकता है? सौभाग्य से, हमें कुछ भी आविष्कार करने की आवश्यकता नहीं है। इस तरह के मामलों के लिए, जावा में दो विशेष वर्ग हैं: BigInteger (पूर्णांकों के लिए) और BigDecimal(फ्लोटिंग-पॉइंट नंबरों के लिए)। उन्हें क्या खास बनाता है? सबसे पहले, सिद्धांत रूप में, उनका कोई अधिकतम आकार नहीं है। हम "सैद्धांतिक रूप से" कहते हैं, क्योंकि अनंत मेमोरी वाले कंप्यूटर नहीं हैं। और यदि आपका प्रोग्राम उपलब्ध मेमोरी की मात्रा से अधिक संख्या बनाता है, तो निश्चित रूप से प्रोग्राम काम नहीं करेगा। लेकिन ऐसे मामलों की संभावना नहीं है। परिणामस्वरूप, हम कह सकते हैं कि BigInteger और BigDecimal वस्तुतः असीमित आकार की संख्याओं का प्रतिनिधित्व कर सकते हैं। इन वर्गों का उपयोग किस लिए किया जाता है? सबसे पहले, अत्यधिक कठोर सटीकता आवश्यकताओं वाली गणनाओं के लिए। उदाहरण के लिए, मानव जीवन कुछ कार्यक्रमों में गणना की सटीकता पर निर्भर हो सकता है (जैसे सॉफ्टवेयर जो हवाई जहाज, रॉकेट या चिकित्सा उपकरण को नियंत्रित करता है)। इसलिए यदि 150वां दशमलव स्थान महत्वपूर्ण है, तो BigDecimalसर्वोत्तम विकल्प है। इसके अलावा, इस वर्ग की वस्तुओं का उपयोग अक्सर वित्त की दुनिया में किया जाता है, जहाँ सबसे छोटे मूल्यों की भी सटीक गणना भी अत्यंत महत्वपूर्ण होती है। आप BigInteger और BigDecimal ऑब्जेक्ट्स के साथ कैसे काम करते हैं और क्या आपको उनके बारे में जानने की ज़रूरत है? इन वर्गों की वस्तुएँ इस प्रकार बनाई जाती हैं:

public class Main {

   public static void main(String[] args) {

       BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
       System.out.println(integer);

       BigDecimal decimal = new BigDecimal("123.444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444");
       System.out.println(decimal);
   }
}

कन्स्ट्रक्टर को स्ट्रिंग पास करना केवल एक संभावित विकल्प है। यहां हम स्ट्रिंग्स का उपयोग करते हैं, क्योंकि हमारी संख्याएँ लंबे और दोहरे के लिए अधिकतम मानों से अधिक हैं , और हमें संकलक को समझाने के लिए किसी तरीके की आवश्यकता है कि हम कौन सी संख्या बनाना चाहते हैं :) 11111111111111111111111111111111111111111111111111111111111111111 कन्स्ट्रक्टर के लिए काम नहीं करेगा: जावा पारित संख्या को आदिम डेटा प्रकारों में से एक में क्रैम करने का प्रयास करेगा, लेकिन यह उनमें से किसी में फिट नहीं होगा। इसलिए वांछित संख्या पास करने के लिए एक स्ट्रिंग का उपयोग करना एक अच्छा विकल्प है। दोनों वर्ग पारित स्ट्रिंग्स से स्वचालित रूप से संख्यात्मक मान निकाल सकते हैं। बड़ी संख्या वाली कक्षाओं के साथ काम करते समय याद रखने वाली एक और महत्वपूर्ण बात यह है कि उनकी वस्तुएं अपरिवर्तनीय ( अपरिवर्तनीय ) हैं। आप पहले से ही अपरिवर्तनीयता से परिचित हैं, स्ट्रिंग वर्ग और आदिम प्रकार (पूर्णांक, लंबा, आदि) के लिए आवरण वर्ग के साथ अपने अनुभव के लिए धन्यवाद ।

import java.math.BigInteger;

public class Main {

   public static void main(String[] args) {

       BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
       System.out.println(integer);

       integer.add(BigInteger.valueOf(33333333));
       System.out.println(integer);

   }
}

कंसोल आउटपुट:

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

जैसा कि आप उम्मीद करेंगे, हमारी संख्या नहीं बदली है। अतिरिक्त ऑपरेशन करने के लिए, ऑपरेशन के परिणाम प्राप्त करने के लिए आपको एक नई वस्तु बनानी होगी।

import java.math.BigInteger;

public class Main {

   public static void main(String[] args) {

       BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
       System.out.println(integer);

       BigInteger result = integer.add(BigInteger.valueOf(33333333));
       System.out.println(result);

   }
}

कंसोल आउटपुट:

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111144444444

देखें, अब सब कुछ वैसा ही काम करता है जैसा उसे होना चाहिए :) वैसे, क्या आपने देखा कि अतिरिक्त ऑपरेशन कितना असामान्य दिखता है?

BigInteger result = integer.add(BigInteger.valueOf(33333333));

यह एक और महत्वपूर्ण बात है। बड़ी संख्या वाली कक्षाएं + - * / ऑपरेटरों का उपयोग नहीं करती हैं। इसके बजाय, वे तरीकों का एक सेट प्रदान करते हैं। आइए मुख्य लोगों से परिचित हों (हमेशा की तरह, आप Oracle प्रलेखन में विधियों की पूरी सूची पा सकते हैं: यहाँ और यहाँ )।

1. अंकगणितीय संचालन के तरीके: जोड़ें () , घटाएं () , गुणा करें () , विभाजित करें () । इन विधियों का उपयोग क्रमशः जोड़, घटाव, गुणा और भाग करने के लिए किया जाता है।

2. DoubleValue() , intValue() , floatValue() , longValue() , आदि का उपयोग बड़ी संख्या को जावा के आदिम प्रकारों में से एक में बदलने के लिए किया जाता है। इन तरीकों का इस्तेमाल करते समय सावधान रहें। बिट आकार में अंतर के बारे में मत भूलना!

   import java.math.BigInteger;
   
   public class Main {
   
      public static void main(String[] args) {
   
          BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
   
          long result = integer.longValue();
          System.out.println(result);
   
      }
   }

   कंसोल आउटपुट:

   8198552921648689607

3. min() और max() आपको दो बड़ी संख्याओं का न्यूनतम और अधिकतम मान ज्ञात करने देता है।
   ध्यान दें कि ये विधियां स्थिर नहीं हैं!

   import java.math.BigInteger;
   
   public class Main {
   
      public static void main(String[] args) {
   
          BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
          BigInteger integer2 = new BigInteger("222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222");
   
          System.out.println(integer.max(integer2));
   
      }
   }

   कंसोल आउटपुट:

   222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

बिगडेसिमल राउंडिंग व्यवहार

इस विषय का अपना एक अलग खंड है, क्योंकि बड़ी संख्याओं का पूर्णांक बनाना और पूर्णांकन व्यवहार को कॉन्फ़िगर करना इतना सरल नहीं है। आप BigDecimal के लिए दशमलव स्थानों की संख्या निर्धारित करने के लिए setScale() विधि का उपयोग कर सकते हैं । उदाहरण के लिए, मान लीजिए कि हम संख्या 111.5555555555 में दशमलव बिंदु के बाद तीन अंक चाहते हैं। हालाँकि, हम संख्या 3 को सेटस्केल () विधि के तर्क के रूप में पास करके जो चाहते हैं उसे प्राप्त नहीं कर सकते हैं। जैसा ऊपर बताया गया है, BigDecimalकम्प्यूटेशनल सटीकता पर सख्त आवश्यकताओं के साथ संख्याओं का प्रतिनिधित्व करने के लिए है। अपने वर्तमान स्वरूप में, हमारी संख्या में दशमलव बिंदु के बाद 10 अंक होते हैं। हम उनमें से 7 को छोड़ना चाहते हैं और केवल 3 को रखना चाहते हैं। तदनुसार, संख्या 3 के अतिरिक्त, हमें राउंडिंग मोड पास करना होगा। BigDecimal में कुल 8 राउंडिंग मोड हैं। यह बहुत ज्यादा है! लेकिन अगर आपको वास्तव में अपनी गणनाओं की सटीकता को ठीक करने की आवश्यकता है, तो आपके पास वह सब कुछ होगा जिसकी आपको आवश्यकता है। तो, यहाँ BigDecimal द्वारा पेश किए गए 8 राउंडिंग मोड हैं :

1. ROUND_CEILING — राउंड अप

   111.5555555555 -> setScale(3, ROUND_CEILING) -> 111.556

2. ROUND_DOWN — शून्य की ओर जाता है

   111.5555555555 -> setScale(3, ROUND_DOWN) -> 111.555

3. ROUND_FLOOR — राउंड डाउन

   111.5555555555 -> setScale(3, ROUND_FLOOR) -> 111.555

4. ROUND_HALF_UP - दशमलव बिंदु के बाद की संख्या> = 0.5 होने पर राउंड अप करें

   0.55 -> setScale(1, ROUND_HALF_UP) -> 0.6
   0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5

5. ROUND_HALF_DOWN - दशमलव बिंदु के बाद की संख्या> 0.5 होने पर राउंड अप करें

   0.55 -> setScale(1, ROUND_HALF_DOWN) -> 0.5
   0.56 -> setScale(1, ROUND_HALF_DOWN) -> 0.6

6. ROUND_HALF_EVEN — पूर्णांकन दशमलव बिंदु के बाईं ओर की संख्या पर निर्भर करता है। यदि बाईं ओर की संख्या सम है, तो गोलाई कम की जाएगी। यदि दशमलव बिंदु के बाईं ओर की संख्या विषम है, तो पूर्णांकन ऊपर किया जाएगा।

   2.5 -> setScale(0, ROUND_HALF_EVEN) -> 2

   दशमलव स्थान के बाईं ओर की संख्या 2 (सम) है। संख्या को गोल कर दिया गया है। हम 0 दशमलव स्थान चाहते हैं, इसलिए परिणाम 2 है।

   3.5 -> setScale(0, ROUND_HALF_EVEN) -> 4

   दशमलव बिंदु के बाईं ओर की संख्या 3 (विषम) है। संख्या गोल है। हम 0 दशमलव स्थान चाहते हैं, इसलिए परिणाम 4 है।

7. ROUND_UNNECCESSARY - इस मोड का उपयोग तब किया जाता है जब आपको राउंडिंग मोड को किसी विधि में पास करना होता है, लेकिन संख्या को गोल करने की आवश्यकता नहीं होती है। यदि आप ROUND_UNNECCESSARY मोड सेट के साथ किसी संख्या को गोल करने का प्रयास करते हैं, तो एक अंकगणितीय अपवाद फेंक दिया जाता है।

   3.51 -> setScale(1, ROUND_UNNECCESSARY) -> ArithmeticException

8. ROUND_UP - शून्य से राउंड दूर।

   111.5551 -> setScale(3, ROUND_UP) -> 111.556

बड़ी संख्याओं की तुलना करना

यह भी महत्वपूर्ण है। आपको याद होगा कि हम जावा में वस्तुओं की तुलना करने के लिए बराबर () विधि का उपयोग करते हैं। कार्यान्वयन या तो भाषा द्वारा ही प्रदान किया जाता है (मानक जावा कक्षाओं के लिए) या प्रोग्रामर द्वारा ओवरराइड किया जाता है। लेकिन BigDecimal ऑब्जेक्ट्स के मामले में , तुलना के लिए बराबर () विधि का उपयोग करने की अनुशंसा नहीं की जाती है। ऐसा इसलिए है क्योंकि BigDecimal.equals() विधि तभी सही होती है जब 2 संख्याओं का मान और पैमाना समान हो: आइए Double और BigDecimal वर्गों के लिए equals() पद्धति के व्यवहार की तुलना करें:

import java.math.BigDecimal;

public class Main {

   public static void main(String[] args) {

       Double a = 1.5;
       Double b = 1.50;

       System.out.println(a.equals(b));

       BigDecimal x = new BigDecimal("1.5");
       BigDecimal y = new BigDecimal("1.50");

       System.out.println(x.equals(y));

   }
}

कंसोल आउटपुट:

true
false

जैसा कि आप देख सकते हैं, BigDecimal के लिए , 1.5 और 1.50 की संख्या असमान निकली! यह BigDecimal वर्ग में बराबर () पद्धति के कार्यान्वयन की विशिष्टता के कारण था । दो BigDecimal ऑब्जेक्ट्स की अधिक सटीक तुलना के लिए , ComparTo() विधि का उपयोग करना बेहतर होता है :

import java.math.BigDecimal;

public class Main {

   public static void main(String[] args) {

       BigDecimal x = new BigDecimal("1.5");
       BigDecimal y = new BigDecimal("1.50");

       System.out.println(x.compareTo(y));

   }
}

कंसोल आउटपुट:

0

तुलना करने के लिए () विधि 0 लौटाती है, जिसका अर्थ है कि 1.5 और 1.50 बराबर हैं। और यह वह परिणाम है जिसकी हमें उम्मीद थी! :) यह आज के हमारे पाठ का समापन करता है। अब कार्यों पर वापस जाने का समय आ गया है! :)