జావా బిగ్ఇంటిజర్ క్లాస్

BigInteger క్లాస్ అంటే ఏమిటి?

జావాలో పూర్ణాంక కార్యకలాపాలను నిర్వహించడానికి పూర్ణాంక లేదా పొడవు వంటి కొన్ని ఆదిమ డేటా రకాలు ఉన్నాయి . అయితే, కొన్నిసార్లు మనం అటువంటి ఆదిమ డేటా రకాల పరిధికి వెలుపల పెద్ద సంఖ్యలను నిల్వ చేయాలి. BigInteger క్లాస్ చాలా పెద్ద సంఖ్యల కోసం గణిత గణనల కోసం ఉపయోగించబడుతుంది. ఇది java.lang.Math ప్యాకేజీ నుండి అన్ని పద్ధతులను మరియు జావా యొక్క అన్ని ఆదిమ పూర్ణాంక ఆపరేటర్‌లకు అనలాగ్‌లను అందిస్తుంది. పెద్ద పూర్ణాంకంక్లాస్ మాడ్యులర్ అంకగణితం, బిట్ మానిప్యులేషన్, GCD లెక్కింపు మరియు కొన్ని ఇతర కార్యకలాపాల కోసం కార్యకలాపాలను కవర్ చేస్తుంది. BigIntegers రెండు పూరక సంజ్ఞామానంలో సూచించబడతాయి. మెమరీ డైనమిక్‌గా కేటాయించబడినందున ఎంత పెద్ద సంఖ్యను నిల్వ చేయవచ్చనే దానిపై సైద్ధాంతిక పరిమితి లేదు. అయినప్పటికీ, ఆచరణాత్మకంగా మెమరీ పరిమితం చేయబడింది మరియు మేము పూర్ణాంకం కంటే తక్కువ లేదా సమానమైన బిట్‌ల సంఖ్యను కలిగి ఉన్న పూర్ణాంకాన్ని నిల్వ చేయవచ్చు . 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 ప్యాకేజీలో ప్రకటించబడింది మరియు నిర్వచించబడింది.

క్లాస్ కన్స్ట్రక్టర్స్

Java యొక్క BigInteger క్లాస్‌లో చాలా ఓవర్‌లోడ్ కన్స్ట్రక్టర్‌లు ఉన్నాయి. అవి ఎలా పని చేస్తాయో చూడడానికి మీరు ప్రతిదాన్ని ఎడిటర్‌లో ప్రయత్నించవచ్చు మరియు అమలు చేయవచ్చు.

తరగతి పద్ధతులు

జావా యొక్క BigInteger తరగతి అనేక పద్ధతులను కలిగి ఉంది, వాటిలో కొన్ని క్రింద వివరించబడ్డాయి. పట్టికలో, 'ఇది' పద్ధతిని పిలిచే BigIntegerని సూచిస్తుంది మరియు ' val ' అనేది పద్ధతికి పంపబడిన వాదన.

ఉదాహరణ 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 క్లాస్‌ని ఉపయోగించి లెక్కించబడుతుంది . మేము గణన ఫాక్టోరియల్ పద్ధతిని సృష్టించాము . ఈ పద్ధతి ఒక BigIntegerని సృష్టిస్తుంది మరియు 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(String val) కన్స్ట్రక్టర్‌ని ఉపయోగించి రెండు BigInteger లను తయారు చేసాము . మేము BigInteger s big1 మరియు big2 లో వరుసగా 20 మరియు 60 విలువలతో విభిన్న పద్ధతులను వర్తింపజేసాము . మేము ఈ క్రింది పద్ధతులను వర్తింపజేసాము:

1. 60 నుండి 20ని తీసివేయడానికి big2.subtract(big1) .
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 క్లాస్ పద్ధతులను ఉపయోగించడం ద్వారా వాటిపై విభిన్న అంకగణిత మరియు తార్కిక కార్యకలాపాలను కూడా చేయగలగాలి . సవాలుగా, మీరు BigInteger s యొక్క విభిన్న విలువలతో విభిన్న పద్ధతులను కాల్ చేయడానికి ప్రయత్నించవచ్చు. ఇది జావాలో BigIntegers గురించి మీ అవగాహనను మరింత బలోపేతం చేస్తుంది . మీ అభ్యాసంపై మరింత నమ్మకంగా ఉండటానికి, దానిని పదే పదే సాధన చేసేందుకు ప్రయత్నించండి. మంచి కోడింగ్‌కి కీలకం సాధన. శుభాకాంక్షలు మరియు సంతోషకరమైన కోడింగ్!