جاوا میں بگ ڈیسیمل

ہائے! آج کے سبق میں، ہم بڑی تعداد کے بارے میں بات کریں گے۔ نہیں، میرا مطلب واقعی بڑا ہے۔ ہم نے پہلے بار بار ڈیٹا کی قدیم اقسام کے لیے قدر کی حدود کے جدول کا سامنا کیا ہے۔ ایسا لگتا ہے: کمرہ والے عددی ڈیٹا کی قسم لمبی ہے ۔ جب بات فلوٹنگ پوائنٹ نمبرز کی ہو تو یہ ڈبل ہے ۔ لیکن کیا ہوگا اگر ہمیں جس تعداد کی ضرورت ہے وہ اتنی بڑی ہے کہ یہ ایک لمبے میں بھی فٹ نہیں بیٹھتی ؟ لانگ ڈیٹا ٹائپ میں ممکنہ قدروں کی کافی بڑی رینج ہے، لیکن یہ اب بھی 64 بٹس تک محدود ہے۔ اگر ہمارے بہت بڑے نمبر کو 100 بٹس کی ضرورت ہے تو ہمیں کیا کرنے کی ضرورت ہے؟ خوش قسمتی سے، ہمیں کچھ بھی ایجاد کرنے کی ضرورت نہیں ہے۔ اس طرح کے معاملات کے لیے، جاوا کی دو خاص کلاسیں ہیں: 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);
   }
}

کنسٹرکٹر کو سٹرنگ دینا صرف ایک ممکنہ آپشن ہے۔ یہاں ہم سٹرنگز کا استعمال کرتے ہیں، کیونکہ ہماری تعداد لمبی اور ڈبل کے لیے زیادہ سے زیادہ قدروں سے زیادہ ہوتی ہے ، اور ہمیں کمپائلر کو یہ بتانے کے لیے کسی طریقے کی ضرورت ہوتی ہے کہ ہم کون سا نمبر بنانا چاہتے ہیں :) بس نمبر کو پاس کرنا کنسٹرکٹر سے 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 کام نہیں کرے گا: 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() , subtract() , multiply() , divide() ۔ یہ طریقے بالترتیب اضافہ، گھٹاؤ، ضرب اور تقسیم کرنے کے لیے استعمال ہوتے ہیں۔

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

بگ ڈیسیمل راؤنڈنگ برتاؤ

اس موضوع کا اپنا الگ سیکشن ہے، کیونکہ بڑے نمبروں کو گول کرنا اور راؤنڈنگ رویے کو ترتیب دینا اتنا آسان نہیں ہے۔ آپ سیٹ اسکیل() طریقہ استعمال کر سکتے ہیں بگ ڈیسیمل کے لیے اعشاریہ مقامات کی تعداد مقرر کرنے کے لیے ۔ مثال کے طور پر، فرض کریں کہ ہم چاہتے ہیں کہ نمبر 111.5555555555 اعشاریہ کے بعد تین ہندسے ہوں۔ تاہم، ہم سیٹ اسکیل() طریقہ کار کی دلیل کے طور پر نمبر 3 کو پاس کر کے وہ حاصل نہیں کر سکتے جو ہم چاہتے ہیں ۔ جیسا کہ اوپر ذکر کیا گیا ہے، BigDecimal کمپیوٹیشنل درستگی پر سخت تقاضوں کے ساتھ اعداد کی نمائندگی کرنے کے لیے ہے۔ اس کی موجودہ شکل میں، ہمارے نمبر میں اعشاریہ کے بعد 10 ہندسے ہیں۔ ہم ان میں سے 7 چھوڑنا چاہتے ہیں اور صرف 3 رکھنا چاہتے ہیں۔ اس کے مطابق، نمبر 3 کے علاوہ، ہمیں راؤنڈنگ موڈ کو پاس کرنا ہوگا۔ BigDecimal میں کل 8 راؤنڈنگ موڈز ہیں۔ یہ بہت ہے! لیکن اگر آپ کو واقعی اپنے حسابات کی درستگی کو ٹھیک کرنے کی ضرورت ہے، تو آپ کے پاس وہ سب کچھ ہوگا جس کی آپ کو ضرورت ہے۔ لہذا، بگ ڈیسیمل کے ذریعہ پیش کردہ 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 موڈ سیٹ کے ساتھ کسی نمبر کو گول کرنے کی کوشش کرتے ہیں، تو ایک ArithmeticException پھینک دیا جاتا ہے۔

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

8. ROUND_UP — صفر سے دور۔

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

بڑی تعداد کا موازنہ کرنا

یہ بھی ضروری ہے۔ آپ کو یاد ہوگا کہ ہم جاوا میں اشیاء کا موازنہ کرنے کا طریقہ برابر () استعمال کرتے ہیں۔ نفاذ یا تو خود زبان کے ذریعہ فراہم کیا جاتا ہے (معیاری جاوا کلاسوں کے لئے) یا پروگرامر کے ذریعہ اوور رائیڈ کیا جاتا ہے۔ لیکن 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 برابر ہیں۔ اور یہ وہی نتیجہ ہے جس کی ہمیں توقع تھی! :) اس سے ہمارا آج کا سبق ختم ہوتا ہے۔ اب کاموں پر واپس جانے کا وقت ہے! :)