ஜாவாவில் பிக்டெசிமல்

வணக்கம்! இன்றைய பாடத்தில், பெரிய எண்களைப் பற்றி பேசுவோம். இல்லை, நான் சொல்வது உண்மையில் பெரியது. பழமையான தரவு வகைகளுக்கான மதிப்பு வரம்புகளின் அட்டவணையை நாங்கள் முன்பு மீண்டும் மீண்டும் சந்தித்துள்ளோம். இது போல் தெரிகிறது: இடமில்லாத முழு எண் தரவு வகை நீளமானது . மிதக்கும் புள்ளி எண்களுக்கு வரும்போது, ​​​​அது இரட்டிப்பாகும் . ஆனால், நமக்குத் தேவையான எண் மிக அதிகமாக இருந்தால், அது ஒரு நீண்ட காலத்திற்குக் கூட பொருந்தாது ? நீண்ட தரவு வகை சாத்தியமான மதிப்புகளின் மிகப் பெரிய வரம்பைக் கொண்டுள்ளது, ஆனால் அது இன்னும் 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);
   }
}

கன்ஸ்ட்ரக்டருக்கு ஒரு சரத்தை அனுப்புவது ஒரு சாத்தியமான விருப்பமாகும். இங்கே நாம் சரங்களைப் பயன்படுத்துகிறோம், ஏனெனில் எங்கள் எண்கள் நீளம் மற்றும் இரட்டிப்புக்கான அதிகபட்ச மதிப்புகளை மீறுகின்றன , மேலும் எந்த எண்ணை உருவாக்க விரும்புகிறோம் என்பதை கம்பைலருக்கு விளக்க சில வழிகள் தேவை :) 1111111111111111111111111111111111111111111111111 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 கன்ஸ்ட்ரக்டருக்கு வேலை செய்யாது: அனுப்பப்பட்ட எண்ணை பழமையான தரவு வகைகளில் ஒன்றாக மாற்ற ஜாவா முயற்சிக்கும், ஆனால் அது அவற்றில் எதற்கும் பொருந்தாது. அதனால்தான் விரும்பிய எண்ணைக் கடக்க ஒரு சரத்தைப் பயன்படுத்துவது ஒரு நல்ல வழி. இரண்டு வகுப்புகளும் தானாக அனுப்பப்பட்ட சரங்களிலிருந்து எண் மதிப்புகளைப் பிரித்தெடுக்க முடியும். பெரிய எண் வகுப்புகளுடன் பணிபுரியும் போது நினைவில் கொள்ள வேண்டிய மற்றொரு முக்கியமான விஷயம் என்னவென்றால், அவற்றின் பொருள்கள் மாறாதவை ( மாறாதவை ). ஸ்ட்ரிங் கிளாஸ் மற்றும் பழமையான வகைகளுக்கான ரேப்பர் வகுப்புகள் (முழு எண், நீளம், முதலியன) ஆகியவற்றுடனான உங்கள் அனுபவத்திற்கு நன்றி, மாறாத தன்மையை நீங்கள் ஏற்கனவே அறிந்திருக்கிறீர்கள் .

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. எண்கணித செயல்பாடுகளுக்கான முறைகள்: சேர்() , கழித்தல்() , பெருக்கல்() , வகுத்தல்() . இந்த முறைகள் முறையே கூட்டல், கழித்தல், பெருக்கல் மற்றும் வகுத்தல் ஆகியவற்றைச் செய்யப் பயன்படுகின்றன.

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 என்ற எண் தசமப் புள்ளிக்குப் பிறகு மூன்று இலக்கங்களைக் கொண்டிருக்க வேண்டும் என்று வைத்துக்கொள்வோம் . இருப்பினும், setScale() முறைக்கு வாதமாக எண் 3 ஐ அனுப்புவதன் மூலம் நாம் விரும்பியதை அடைய முடியாது . மேலே குறிப்பிட்டுள்ளபடி, பிக்டெசிமல்கணக்கீட்டு துல்லியத்தின் மீது கடுமையான தேவைகள் கொண்ட எண்களைக் குறிக்கும். அதன் தற்போதைய வடிவத்தில், தசம புள்ளிக்குப் பிறகு எங்கள் எண்ணில் 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

பெரிய எண்களை ஒப்பிடுதல்

இதுவும் முக்கியமானது. ஜாவாவில் பொருள்களை ஒப்பிடுவது சமம்() முறையைப் பயன்படுத்துகிறோம் என்பது உங்களுக்கு நினைவிருக்கும் . செயல்படுத்தல் மொழியால் வழங்கப்படுகிறது (நிலையான ஜாவா வகுப்புகளுக்கு) அல்லது புரோகிராமரால் மேலெழுதப்படுகிறது. ஆனால் பிக்டெசிமல் பொருள்களின் விஷயத்தில் , ஒப்பீடுகளுக்கு சமம்() முறையைப் பயன்படுத்துவது பரிந்துரைக்கப்படவில்லை. ஏனென்றால், 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 பொருள்களை மிகவும் துல்லியமாக ஒப்பிடுவதற்கு , 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 சமம். இது நாம் எதிர்பார்த்த முடிவு! :) இன்று நமது பாடம் முடிவடைகிறது. இப்போது பணிகளுக்குத் திரும்புவதற்கான நேரம் இது! :)