ஜாவா பிக்இண்டிகர் வகுப்பு

பிக்இண்டிகர் வகுப்பு என்றால் என்ன?

ஜாவாவில் சில பழமையான தரவு வகைகள் உள்ளன , அவை முழு எண் செயல்பாடுகளைச் செய்ய முழு எண்ணாக அல்லது நீளமாக பயன்படுத்தப்படுகின்றன. இருப்பினும், சில சமயங்களில் இதுபோன்ற பழமையான தரவு வகைகளின் எல்லைக்கு வெளியே பெரிய எண்களை நாம் சேமிக்க வேண்டும். BigInteger Class என்பது மிகப் பெரிய எண்களுக்கான கணிதக் கணக்கீடுகளுக்குப் பயன்படுத்தப்படுகிறது. இது java.lang.Math தொகுப்பிலிருந்து அனைத்து முறைகளையும் ஜாவாவின் அனைத்து பழமையான முழு எண் ஆபரேட்டர்களுக்கும் ஒப்புமைகளை வழங்குகிறது. பெரிய முழு எண்வகுப்பு மட்டு எண்கணிதம், பிட் கையாளுதல், GCD கணக்கீடு மற்றும் சில செயல்பாடுகளுக்கான செயல்பாடுகளை உள்ளடக்கியது. பிக்இண்டீஜர்கள் இரண்டு-நிறைவு குறிப்பில் குறிப்பிடப்படுகின்றன. நினைவகம் மாறும் வகையில் ஒதுக்கப்படுவதால், எவ்வளவு பெரிய எண்ணைச் சேமிக்க முடியும் என்பதற்கு கோட்பாட்டு வரம்பு இல்லை. இருப்பினும், நடைமுறையில் நினைவகம் குறைவாக உள்ளது மற்றும் முழு எண்ணை விட குறைவான அல்லது அதற்கு சமமான பிட்களின் எண்ணிக்கையைக் கொண்ட ஒரு முழு எண்ணை நாம் சேமிக்க முடியும். MAX_VALUE . இது நடைமுறையில் கிட்டத்தட்ட அனைத்து பெரிய எண்களையும் சேமிக்க போதுமான பெரிய மேல் வரம்பை வழங்குகிறது.

BigInteger வகுப்பு எவ்வாறு செயல்படுத்தப்படுகிறது?

import java.math.BigInteger;

உங்கள் குறியீட்டில் BigInteger வகுப்பைச் செயல்படுத்த , நீங்கள் java.math.BigInteger தொகுப்பை இறக்குமதி செய்ய வேண்டும்.

பெரிய முழு எண் வகுப்பு அறிவிப்பு

ஜாவாவில் உள்ள BigInteger வகுப்பு java.math தொகுப்பில் பின்வரும் வழியில் அறிவிக்கப்படுகிறது :

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

BigInteger வகுப்பு எண் வகுப்பை விரிவுபடுத்துகிறது மற்றும் ஒப்பிடக்கூடிய இடைமுகத்தை செயல்படுத்துகிறது. இது java.math தொகுப்பில் அறிவிக்கப்பட்டு வரையறுக்கப்பட்டுள்ளது .

வகுப்பு கட்டமைப்பாளர்கள்

ஜாவாவின் பிக்இண்டேஜர் வகுப்பில் பல ஓவர்லோடட் கன்ஸ்ட்ரக்டர்கள் உள்ளன. அவை எவ்வாறு செயல்படுகின்றன என்பதைப் பார்க்க, ஒவ்வொன்றையும் எடிட்டரில் இயக்க முயற்சி செய்யலாம்.

வகுப்பு முறைகள்

ஜாவாவின் BigInteger வகுப்பில் பல முறைகள் உள்ளன, அவற்றில் சில கீழே விவரிக்கப்பட்டுள்ளன. அட்டவணையில், 'இது' பிக்இண்டீஜரைக் குறிக்கிறது , இது முறையை அழைக்கிறது மற்றும் ' வால் ' என்பது முறைக்கு அனுப்பப்பட்ட வாதமாகும்.

எடுத்துக்காட்டு 1

import java.math.BigInteger;
public class Example1 {
    static BigInteger calculateFactorial(int val) {
        // Initialize result
        BigInteger f = BigInteger.ONE; // Or new BigInteger("1")
        // compute factorial
        for (int i = 2; i <= val; i++) {
            f = f.multiply(BigInteger.valueOf(i));
        }

        return f;
    }

    // Driver method
    public static void main(String[] args) {
        int val = 25;
        System.out.println(calculateFactorial(val));
    }
}

வெளியீடு

விளக்கம்

மேலே உள்ள துணுக்கில், java.math.BigInteger தொகுப்பை இறக்குமதி செய்வதன் மூலம் BigInteger Class ஐப் பயன்படுத்தி ஒரு பெரிய எண்ணின் காரணி கணக்கிடப்படுகிறது . நாங்கள் ஒரு கணக்கிடும் காரணி முறையை உருவாக்கியுள்ளோம் . இந்த முறை ஒரு பெரியஇண்டீஜரை உருவாக்கி, பின்னர் பெருக்கல் முறை f.multiply(BigInteger.valueOf(i)) ஐப் பயன்படுத்தி காரணியைக் கணக்கிடுகிறது .

உதாரணம் 2

import java.math.BigInteger;
public class Example2 {

    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("20");
        BigInteger big2 = new BigInteger("60");
        BigInteger sub = big2.subtract(big1);
        System.out.println(big2 + " - " + big1 + " = " + sub);
        BigInteger add = big1.add(big2);
        System.out.println(big1 + " + " + big2 + " = " + add);
        BigInteger mul = big1.multiply(big2);
        System.out.println(big1 + " * " + big2 + " = " + mul);
        BigInteger div = big2.divide(big1);
        System.out.println(big2 + " / " + big1 + " = " + div);
        BigInteger min = big1.min(big2);
        System.out.println("min value: " + min);
        BigInteger max = big1.max(big2);
        System.out.println("max value: " + max);
    }
}

வெளியீடு

விளக்கம்

மேலே உள்ள துணுக்கில், BigInteger(ஸ்ட்ரிங் வால்) கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி இரண்டு BigInteger களை உருவாக்கியுள்ளோம் . BigInteger s big1 மற்றும் big2 இல் முறையே 20 மற்றும் 60 மதிப்புகளுடன் வெவ்வேறு முறைகளைப் பயன்படுத்தினோம் . நாங்கள் பின்வரும் முறைகளைப் பயன்படுத்தினோம்:

1. 60ல் இருந்து 20ஐ கழிக்க பெரிய2.கழித்தல்(பெரிய1) .
2. 20 மற்றும் 60 ஐ சேர்க்க big1.add(big2) .
3. big1.multiply(big2) 20 மற்றும் 60ஐ பெருக்க.
4. big2.divide(big1) 60ஐ 20ஆல் வகுக்க.
5. இரண்டு மதிப்புகளில் சிறியதைப் பெற big1.min(big2) .
6. இரண்டு மதிப்புகளில் பெரியதைப் பெற big1.max(big2) .

குறியீட்டின் மேல் பகுதியில் java.math.BigInteger இறக்குமதி செய்யப்பட்டுள்ளது என்பதை கவனத்தில் கொள்ள வேண்டும் .

முடிவுரை

ஜாவாவில் உள்ள BigInteger வகுப்பை நீங்கள் இப்போது நன்கு அறிந்திருக்க வேண்டும் . வெவ்வேறு வகையான கட்டமைப்பாளர்களைப் பயன்படுத்தி உங்கள் குறியீட்டில் BigInteger களை நீங்கள் பயன்படுத்த முடியும் . BigInteger Class முறைகளைப் பயன்படுத்தி நீங்கள் வெவ்வேறு எண்கணித மற்றும் தருக்க செயல்பாடுகளைச் செய்ய முடியும் . சவாலாக, BigInteger s இன் வெவ்வேறு மதிப்புகளுடன் வெவ்வேறு முறைகளை அழைக்க முயற்சி செய்யலாம். ஜாவாவில் BigInteger கள் பற்றிய உங்கள் புரிதலை இது மேலும் வலுப்படுத்தும் . உங்கள் கற்றலில் அதிக நம்பிக்கையுடன் இருக்க, அதை மீண்டும் மீண்டும் பயிற்சி செய்ய முயற்சிக்கவும். நல்ல குறியீட்டுக்கான திறவுகோல் பயிற்சி. நல்ல அதிர்ஷ்டம் மற்றும் மகிழ்ச்சியான குறியீட்டு முறை!