Java मध्ये BigDecimal

हाय! आजच्या धड्यात, आपण मोठ्या संख्येबद्दल बोलू. नाही, मला खरोखर मोठे म्हणायचे आहे. आदिम डेटा प्रकारांसाठी आम्ही याआधी वारंवार मूल्य श्रेणींच्या सारणीचा सामना केला आहे. हे असे दिसते: खोलीतील पूर्णांक डेटा प्रकार लांब आहे . जेव्हा फ्लोटिंग-पॉइंट संख्यांचा विचार केला जातो तेव्हा ते दुहेरी असते . पण जर आपल्याला आवश्यक असलेली संख्या इतकी मोठी असेल की ती लांबतही बसत नसेल तर ? लाँग डेटा प्रकारात संभाव्य मूल्यांची बरीच मोठी श्रेणी आहे, परंतु तरीही ती 64 बिट्सपर्यंत मर्यादित आहे. आमच्या खूप मोठ्या संख्येला 100 बिट आवश्यक असल्यास आम्हाला काय करावे लागेल? सुदैवाने, आम्हाला काहीही शोधण्याची गरज नाही. अशा प्रकरणांसाठी, Java मध्ये दोन विशेष वर्ग आहेत: BigInteger (पूर्णांकांसाठी) आणि BigDecimal(फ्लोटिंग-पॉइंट नंबरसाठी). त्यांना काय खास बनवते? सर्व प्रथम, सिद्धांतानुसार, त्यांच्याकडे कमाल आकार नाही. आम्ही "सिद्धांतात" म्हणतो, कारण असीम मेमरी असलेले कोणतेही संगणक नाहीत. आणि जर तुमचा प्रोग्राम उपलब्ध मेमरीच्या प्रमाणापेक्षा मोठी संख्या तयार करतो, तर, प्रोग्राम नक्कीच कार्य करणार नाही. परंतु अशी प्रकरणे संभवत नाहीत. परिणामी, आम्ही म्हणू शकतो की BigInteger आणि BigDecimal अक्षरशः अमर्यादित आकाराच्या संख्येचे प्रतिनिधित्व करू शकतात. हे वर्ग कशासाठी वापरले जातात? सर्व प्रथम, अत्यंत कठोर अचूकतेच्या आवश्यकतांसह गणनासाठी. उदाहरणार्थ, मानवी जीवन काही प्रोग्राम्समधील गणनेच्या अचूकतेवर अवलंबून असू शकते (उदा. विमान, रॉकेट किंवा वैद्यकीय उपकरणे नियंत्रित करणारे सॉफ्टवेअर). त्यामुळे 150 व्या दशांश स्थान महत्त्वाचे असल्यास, बिगडेसिमलसर्वोत्तम निवड आहे. याव्यतिरिक्त, या वर्गाच्या वस्तूंचा वापर वित्त जगामध्ये केला जातो, जेथे अगदी लहान मूल्यांची अचूक गणना करणे देखील अत्यंत महत्वाचे आहे. तुम्ही 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);
   }
}

कन्स्ट्रक्टरला स्ट्रिंग पास करणे हा फक्त एक संभाव्य पर्याय आहे. येथे आपण स्ट्रिंग्स वापरतो, कारण आपली संख्या लांब आणि दुप्पट साठी जास्तीत जास्त मूल्यांपेक्षा जास्त आहे , आणि आपल्याला कोणती संख्या तयार करायची आहे हे कंपाइलरला समजावून सांगण्यासाठी आपल्याला काही मार्ग आवश्यक आहेत :) फक्त संख्या पास करणे 1111111111111111111111111111111111111111111111111111111111111111111111111111 कन्स्ट्रक्टरसाठी कार्य करणार नाही: Java पास केलेल्या नंबरला एका आदिम डेटा प्रकारात क्रॅम करण्याचा प्रयत्न करेल, परंतु ते त्यापैकी कोणत्याहीमध्ये बसणार नाही. म्हणूनच इच्छित संख्या पास करण्यासाठी स्ट्रिंग वापरणे हा एक चांगला पर्याय आहे. दोन्ही वर्ग आपोआप पास केलेल्या स्ट्रिंगमधून संख्यात्मक मूल्ये काढू शकतात. मोठ्या-संख्येच्या वर्गांसह काम करताना लक्षात ठेवण्याचा आणखी एक महत्त्वाचा मुद्दा म्हणजे त्यांच्या वस्तू अपरिवर्तनीय ( अपरिवर्तनीय ) आहेत. स्ट्रिंग क्लास आणि आदिम प्रकारांसाठी (पूर्णांक, लांब, इ.) रॅपर क्लासेसच्या अनुभवामुळे तुम्ही अचलतेशी आधीच परिचित आहात .

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

हा आणखी एक महत्त्वाचा मुद्दा आहे. मोठ्या-संख्येचे वर्ग + - * / ऑपरेटर वापरत नाहीत. त्याऐवजी, ते पद्धतींचा संच प्रदान करतात. चला मुख्य गोष्टींशी परिचित होऊ या (नेहमीप्रमाणे, तुम्हाला ओरॅकल दस्तऐवजीकरणातील पद्धतींची संपूर्ण यादी मिळेल: येथे आणि येथे ).

1. अंकगणित ऑपरेशन्सच्या पद्धती: add() , वजा () , गुणाकार () , divide() . या पद्धतींचा वापर अनुक्रमे बेरीज, वजाबाकी, गुणाकार आणि भागाकार करण्यासाठी केला जातो.

2. doubleValue() , intValue() , floatValue() , longValue() , इ. मोठ्या संख्येला Java च्या आदिम प्रकारात रूपांतरित करण्यासाठी वापरले जातात. या पद्धती वापरताना काळजी घ्या. बिट आकारातील फरकांबद्दल विसरू नका!

   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 rounding वर्तन

या विषयाचा स्वतःचा स्वतंत्र विभाग आहे, कारण मोठ्या संख्येचे पूर्णीकरण करणे आणि गोलाकार वर्तन कॉन्फिगर करणे इतके सोपे नाही. BigDecimal साठी दशांश स्थानांची संख्या सेट करण्यासाठी तुम्ही setScale() पद्धत वापरू शकता . उदाहरणार्थ, समजा 111.5555555555 या संख्येला दशांश बिंदूनंतर तीन अंक हवे आहेत. तथापि, आम्ही setScale() पद्धतीसाठी वितर्क म्हणून क्रमांक 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.55 -> setScale(1, ROUND_HALF_UP) -> 0.6
   0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5

5. ROUND_HALF_DOWN — दशांश बिंदू > ०.५ नंतरची संख्या असल्यास पूर्णांक

   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

मोठ्या संख्येची तुलना

हे देखील महत्त्वाचे आहे. तुम्हाला आठवत असेल की आम्ही Java मधील ऑब्जेक्ट्सची तुलना करण्यासाठी equals() पद्धत वापरतो. अंमलबजावणी एकतर भाषेद्वारे प्रदान केली जाते (मानक Java वर्गांसाठी) किंवा प्रोग्रामरद्वारे अधिलिखित केले जाते. परंतु BigDecimal ऑब्जेक्ट्सच्या बाबतीत , तुलनेसाठी equals() पद्धत वापरण्याची शिफारस केलेली नाही. याचे कारण असे की BigDecimal.equals() पद्धत 2 संख्यांचे मूल्य आणि स्केल समान असल्यासच खरे मिळते: दुहेरी आणि 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 वर्गात equals() पद्धतीच्या अंमलबजावणीच्या वैशिष्ट्यांमुळे होते . दोन BigDecimal ऑब्जेक्ट्सची अधिक अचूक तुलना करण्यासाठी , compareTo() पद्धत वापरणे चांगले आहे :

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

compareTo () पद्धतीने 0 परत केले, याचा अर्थ 1.5 आणि 1.50 समान आहेत. आणि हा परिणाम आम्हाला अपेक्षित आहे! :) आज आपला धडा संपतो. आता कार्यांवर परत जाण्याची वेळ आली आहे! :)