జావాలో బిగ్ డెసిమల్

హాయ్! నేటి పాఠంలో, మేము పెద్ద సంఖ్యల గురించి మాట్లాడుతాము. లేదు, నా ఉద్దేశ్యం నిజంగా పెద్దది. మేము మునుపు పదే పదే ఆదిమ డేటా రకాల విలువ పరిధుల పట్టికను ఎదుర్కొన్నాము. ఇది ఇలా కనిపిస్తుంది: రూమియెస్ట్ పూర్ణాంక డేటా రకం పొడవుగా ఉంటుంది . ఫ్లోటింగ్ పాయింట్ సంఖ్యల విషయానికి వస్తే, ఇది రెట్టింపు . కానీ మనకు అవసరమైన సంఖ్య చాలా పెద్దది అయితే అది పొడవుగా కూడా సరిపోకపోతే ? లాంగ్ డేటా రకం సాధ్యమయ్యే విలువల యొక్క చాలా పెద్ద పరిధిని కలిగి ఉంది, అయితే ఇది ఇప్పటికీ 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);
   }
}

స్ట్రింగ్‌ను కన్స్ట్రక్టర్‌కు పంపడం అనేది ఒక అవకాశం మాత్రమే. ఇక్కడ మేము స్ట్రింగ్‌లను ఉపయోగిస్తాము, ఎందుకంటే మా సంఖ్యలు పొడవు మరియు రెట్టింపు కోసం గరిష్ట విలువలను మించిపోయాయి మరియు కంపైలర్‌కు మనం ఏ సంఖ్యను సృష్టించాలనుకుంటున్నామో వివరించడానికి మాకు కొంత మార్గం అవసరం :) 11111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111 కన్స్ట్రక్టర్‌కు పని చేయదు: జావా పాస్ చేసిన నంబర్‌ను ఆదిమ డేటా రకాల్లో ఒకదానికి క్రామ్ చేయడానికి ప్రయత్నిస్తుంది, కానీ అది వాటిలో దేనికీ సరిపోదు. అందుకే కోరుకున్న సంఖ్యను పాస్ చేయడానికి స్ట్రింగ్‌ను ఉపయోగించడం మంచి ఎంపిక. రెండు తరగతులు పాస్ చేసిన స్ట్రింగ్‌ల నుండి స్వయంచాలకంగా సంఖ్యా విలువలను సంగ్రహించగలవు. పెద్ద సంఖ్యలో తరగతులతో పనిచేసేటప్పుడు గుర్తుంచుకోవలసిన మరో ముఖ్యమైన విషయం ఏమిటంటే, వారి వస్తువులు మార్పులేనివి ( ఇమ్యుటబుల్ ). స్ట్రింగ్ క్లాస్ మరియు ప్రిమిటివ్ రకాల (పూర్ణాంకం, లాంగ్, మొదలైనవి) కోసం రేపర్ క్లాస్‌లతో మీ అనుభవానికి ధన్యవాదాలు, మార్పులేనితనం గురించి మీకు ఇప్పటికే బాగా తెలుసు .

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() , మొదలైనవి పెద్ద సంఖ్యను జావా యొక్క ఆదిమ రకాలుగా మార్చడానికి ఉపయోగించబడతాయి. ఈ పద్ధతులను ఉపయోగించినప్పుడు జాగ్రత్తగా ఉండండి. బిట్ పరిమాణంలో తేడాల గురించి మర్చిపోవద్దు!

   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 అనే సంఖ్యకు మూడు అంకెలు ఉండాలి అనుకుందాం . అయితే, సెట్‌స్కేల్() పద్ధతికి ఆర్గ్యుమెంట్‌గా నంబర్ 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.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

పెద్ద సంఖ్యలను పోల్చడం

ఇది కూడా ముఖ్యం. జావాలో వస్తువులను సరిపోల్చడం అనేది మేము సమాన () పద్ధతిని ఉపయోగిస్తాము అని మీరు గుర్తుంచుకుంటారు . అమలు అనేది భాష ద్వారా అందించబడుతుంది (ప్రామాణిక జావా తరగతులకు) లేదా ప్రోగ్రామర్ ద్వారా భర్తీ చేయబడుతుంది. కానీ BigDecimal ఆబ్జెక్ట్‌ల విషయంలో , పోలికల కోసం సమాన() పద్ధతిని ఉపయోగించడం సిఫార్సు చేయబడదు. ఎందుకంటే, 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 సమానంగా ఉంటాయి. మరియు ఇది మేము ఊహించిన ఫలితం! :) అది ఈ రోజు మన పాఠాన్ని ముగించింది. ఇప్పుడు విధులకు తిరిగి రావడానికి సమయం ఆసన్నమైంది! :)