డబుల్ రకం - వాస్తవ సంఖ్యలు

1. doubleరకం

జావా doubleవాస్తవ (ఫ్రాక్షనల్) సంఖ్యలతో పని చేయడానికి రకాన్ని అందిస్తుంది. ఇది 8 bytesమెమరీలో ఆక్రమిస్తుంది (రకం కంటే రెండు రెట్లు ఎక్కువ ) మరియు నుండి intపరిధిలో విలువలను నిల్వ చేయగలదు . పోలిక కోసం: రకం నుండి వరకు పరిధిలో విలువను నిల్వ చేయవచ్చు .-1.7*10308+1.7*10308int-2*109+2*109

వాస్తవ సంఖ్యలలో, పాక్షిక భాగం దశాంశ బిందువు తర్వాత వ్రాయబడుతుంది. ఉదాహరణకు, 123.456, లేదా 2.5, లేదా 100.00, లేదా 0.01. కంప్యూటర్లు అటువంటి సంఖ్యలతో వ్యవహరించినప్పుడు, మేము వాటిని ఫ్లోటింగ్ పాయింట్ నంబర్లు అని పిలుస్తాము.

మార్గం ద్వారా, రకానికి అదనంగా double, మనకు floatరకం కూడా ఉంది (ఇది పరిమాణంలో 4 బైట్లు మాత్రమే). దీని పేరు ఫ్లోటింగ్ పాయింట్ నుండి వచ్చింది . మరియు పేరు డబుల్ ఫ్లోట్double నుండి వచ్చింది . A కంటే రెండు రెట్లు పెద్దది : వర్సెస్ . దీనిని డబుల్ ప్రెసిషన్ ఫ్లోటింగ్ పాయింట్ నంబర్ అని కూడా అంటారు .doublefloat8 bytes4

2. ఒక doubleరకాన్ని సృష్టించడం

వాస్తవ సంఖ్యలను నిల్వ చేయడానికి డబుల్ రకం ఉపయోగించబడుతుంది. వాస్తవ సంఖ్యలను నిల్వ చేయగల కోడ్‌లో వేరియబుల్‌ని సృష్టించడానికి, మీరు ఇలాంటి స్టేట్‌మెంట్‌ను ఉపయోగించాలి:

double name;

పేరు అనేది వేరియబుల్ పేరు. ఉదాహరణలు:

double price;

double weight;

double lightSpeed;

రకం వలె , మీరు ఏకకాలంలో intబహుళ వేరియబుల్‌లను సృష్టించడానికి సంక్షిప్తలిపిని ఉపయోగించవచ్చు :double

double name 1, name 2, name 3;

మరియు వెంటనే వాటికి విలువలను కేటాయించండి:

double name 1 = value 1, name 2 = value 2, name 3 = value 3;

ఉదాహరణలు:

double price = 5.0;

double weight = 2;

double x = 1.0, y = 2.0, z = 3.0;

3. పూర్ణాంకాలు మరియు వాస్తవ సంఖ్యలను కేటాయించడం

intపూర్ణాంకాలను వేరియబుల్స్‌కు మాత్రమే కేటాయించగలిగితే మరియు వాస్తవ సంఖ్యలు - వేరియబుల్స్‌కు మాత్రమే కేటాయించబడితే అది చెడ్డది double. మేము రెండు రకాల సంఖ్యల మధ్య మార్చగలగాలి. మరియు జావా ఈ సామర్థ్యాన్ని అందిస్తుంది.

doubleమొదట, వాస్తవ మరియు పూర్ణాంక సంఖ్యలు రెండింటినీ వేరియబుల్స్‌కు కేటాయించవచ్చు . పూర్ణాంకాలను కేటాయించేటప్పుడు, అవి కేవలం వాస్తవ సంఖ్యలకు మార్చబడతాయి. వాస్తవానికి, ప్రక్రియలో కొంత ఖచ్చితత్వం కోల్పోవచ్చు.

double price = 5.0;

double weight = 2;

int t = 1000;
double x =  t * t;

రెండవది, ఏదైనా వ్యక్తీకరణలో పూర్ణాంకం మరియు వాస్తవ సంఖ్య చేరి ఉంటే, పూర్ణాంకం మొదట వాస్తవ సంఖ్యగా మార్చబడుతుంది మరియు ఆ తర్వాత మాత్రమే ఇతర వాస్తవ సంఖ్యతో ఆపరేషన్ చేయబడుతుంది.

int t = 1000;
double x = t * 5.0;

System.out.println(5 * 2);

System.out.println(5 * 2.0);

చివరగా, వేరియబుల్స్‌కు వాస్తవ సంఖ్యలను కేటాయించడం కూడా సాధ్యమే int. మేము దీన్ని చేసినప్పుడు, వాస్తవ సంఖ్య యొక్క పాక్షిక భాగం విస్మరించబడుతుంది - సంఖ్య సమీప పూర్ణ సంఖ్యకు గుండ్రంగా ఉంటుంది.

అదనంగా, కంపైలర్ ప్రోగ్రామర్ ఏమి జరుగుతుందో స్పష్టంగా డాక్యుమెంట్ చేయవలసి ఉంటుంది (ఇతర ప్రోగ్రామర్లు పాక్షిక భాగం డ్రాప్ చేయబడిందని ఖచ్చితంగా అర్థం చేసుకోవడానికి). సాధారణంగా, అటువంటి మార్పిడి కోడ్‌లో ఇలా కనిపిస్తుంది:

integer_variable = (int)(real_number);

ఉదాహరణలు:

int x = (int)(5.5);

double a = 5.999;
int x = (int)(a);

double a = 5.999;
int b = 2;
int x = (int)(a * b);

4. జావాలో పూర్ణాంకాలు మరియు వాస్తవ సంఖ్యలను విభజించడం

పూర్ణాంకాన్ని పూర్ణాంకంతో భాగించినప్పుడు, మిగిలినది ఎల్లప్పుడూ విస్మరించబడుతుంది. 5అలాంటప్పుడు మనం 2ఎలా విభజించవచ్చు 2.5?

మొదట, ఇది సరైన ఎంపికగా కనిపిస్తుంది:

double d = 5 / 2;

కానీ అది అంత సులభం కాదు. ఇక్కడ సమస్య ఏమిటంటే, జావా మెషీన్ మొదట విలువను లెక్కిస్తుంది 5 / 2మరియు ఆ తర్వాత మాత్రమే వేరియబుల్‌కు ఫలితాన్ని కేటాయిస్తుంది d. మరియు 5 / 2ఆపరేషన్ పూర్ణాంక విభజన. అంటే d కలిగి ఉంటుంది 2లేదా, మరింత ఖచ్చితంగా చెప్పాలంటే,2.0

విభజనలో పాల్గొన్న సంఖ్యలలో కనీసం ఒకదానిని వాస్తవ సంఖ్యగా వ్రాయడం సరైన పరిష్కారం (అంటే దశాంశ బిందువుతో):

double d = 5.0 / 2;

double d = 5 / 2.0;

double d = 5.0 / 2.0;

ప్రతి వ్యక్తీకరణలో, d కలిగి ఉంటుంది2.5

అయితే మనం వేరియబుల్స్‌తో పని చేస్తుంటే? మనకు ఇలాంటి కోడ్ ఉంటే?:

int a = 5;
int b = 2;
double d = a / b;

ఇక్కడ ఒక వివేక (మరియు స్పష్టమైన) పరిష్కారం ఉంది - జావా మెషీన్‌ను వాస్తవ సంఖ్యగా ఒకటితో గుణించడం ద్వారా వేరియబుల్‌లను వాస్తవ సంఖ్యలుగా మార్చమని బలవంతం చేయండి ( 1.0)

int a = 5;
int b = 2;
double d = a * 1.0 / b;

గుణకారం మరియు భాగహారం సమాన ప్రాధాన్యతను కలిగి ఉన్నాయని మరియు ఎడమ నుండి కుడికి నిర్వహించబడుతుందని గమనించండి. అంటే మనం 1.0ని ఎక్కడ గుణించాలి అనేది ముఖ్యం.

ఉదాహరణలు:

int a = 5;
int b = 2;
double d = 1.0 * a / b;

int a = 5;
int b = 2;
double d = a * 1.0 / b;

int a = 5;
int b = 2;
double d = a / b * 1.0;