ఆదిమ రకం | మెమరీలో పరిమాణం | విలువ పరిధి |
---|---|---|
బైట్ | 8 బిట్ | -128 నుండి 127 |
చిన్నది | 16 బిట్ | -32768 నుండి 32767 వరకు |
చార్ | 16 బిట్ | 0 నుండి 65536 వరకు |
int | 32 బిట్లు | -2147483648 నుండి 2147483647 వరకు |
పొడవు | 64 బిట్ | -9223372036854775808 నుండి 9223372036854775807 వరకు |
తేలుతుంది | 32 బిట్లు | (2 నుండి పవర్ ఆఫ్ -149) నుండి ((2 నుండి పవర్ ఆఫ్ -23) * 2 నుండి 127 పవర్ వరకు) |
రెట్టింపు | 64 బిట్ | (-2 నుండి 63 వరకు) నుండి ((2 నుండి 63 వరకు) - 1) |
బూలియన్ | 8 (శ్రేణులలో ఉపయోగించినప్పుడు), 32 (అరేలలో ఉపయోగించనప్పుడు) | నిజమా లేక అబధ్ధమా |
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));
ఇది మరొక ముఖ్యమైన అంశం. పెద్ద-సంఖ్య తరగతులు + - * / ఆపరేటర్లను ఉపయోగించవు. బదులుగా, వారు కొన్ని పద్ధతులను అందిస్తారు. ప్రధానమైన వాటితో పరిచయం చేసుకుందాం (ఎప్పటిలాగే, మీరు ఒరాకిల్ డాక్యుమెంటేషన్లో పద్ధతుల యొక్క పూర్తి జాబితాను కనుగొనవచ్చు: ఇక్కడ మరియు ఇక్కడ ).
-
అంకగణిత కార్యకలాపాల పద్ధతులు: add() , వ్యవకలనం() , గుణకారం() , divide() . ఈ పద్ధతులు వరుసగా కూడిక, తీసివేత, గుణకారం మరియు భాగహారం చేయడానికి ఉపయోగించబడతాయి.
-
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
-
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 రౌండింగ్ మోడ్లు ఇక్కడ ఉన్నాయి :-
ROUND_CEILING — రౌండ్లు అప్
111.5555555555 -> setScale(3, ROUND_CEILING) -> 111.556
-
ROUND_DOWN — సున్నా వైపు రౌండ్లు
111.5555555555 -> setScale(3, ROUND_DOWN) -> 111.555
-
ROUND_FLOOR — రౌండ్ డౌన్
111.5555555555 -> setScale(3, ROUND_FLOOR) -> 111.555
-
ROUND_HALF_UP — దశాంశ బిందువు >= 0.5 తర్వాత సంఖ్య ఉంటే పూర్తి అవుతుంది
0.55 -> setScale(1, ROUND_HALF_UP) -> 0.6 0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5
-
ROUND_HALF_DOWN — దశాంశ బిందువు > 0.5 తర్వాత సంఖ్య ఉంటే పూర్తి అవుతుంది
0.55 -> setScale(1, ROUND_HALF_DOWN) -> 0.5 0.56 -> setScale(1, ROUND_HALF_DOWN) -> 0.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.
-
ROUND_UNNECCESSARY — మీరు తప్పనిసరిగా రౌండింగ్ మోడ్ను ఒక పద్ధతికి పాస్ చేసినప్పుడు ఈ మోడ్ ఉపయోగించబడుతుంది, కానీ సంఖ్యను రౌండ్ చేయాల్సిన అవసరం లేదు. మీరు ROUND_UNNECCESSARY మోడ్ సెట్తో సంఖ్యను రౌండ్ చేయడానికి ప్రయత్నిస్తే, అంకగణిత మినహాయింపు విసిరివేయబడుతుంది.
3.51 -> setScale(1, ROUND_UNNECCESSARY) -> ArithmeticException
-
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 సమానంగా ఉంటాయి. మరియు ఇది మేము ఊహించిన ఫలితం! :) అది ఈ రోజు మన పాఠాన్ని ముగించింది. ఇప్పుడు విధులకు తిరిగి రావడానికి సమయం ఆసన్నమైంది! :)
GO TO FULL VERSION