జావా డబుల్ కీవర్డ్

జావా డబుల్ కీవర్డ్, ఏదైనా ఇతర భాషలో వలె, మెమరీలో 64 బిట్‌లు లేదా 8 బైట్‌లను ఆక్రమించే ఫ్లోటింగ్ పాయింట్ నంబర్‌ను సూచించడానికి కంప్యూటర్ ఆకృతిని సూచిస్తుంది. ఈ వ్యాసంలో మనం డబుల్ గురించి మాట్లాడబోతున్నాము మరియు కొన్ని ఉదాహరణలను పరిశీలిస్తాము.

ఫ్లోటింగ్ పాయింట్ మరియు కంప్యూటింగ్: ఒక చిన్న గణిత వివరణ

భిన్న సంఖ్యలు స్థిరంగా లేదా ఫ్లోటింగ్ పాయింట్‌గా ఉంటాయి. మొదటి ఎంపికను సాధారణ భిన్నం వలె సూచించవచ్చు, ఇక్కడ న్యూమరేటర్ (సంఖ్య కూడా) మరియు హారం (దాని స్కేలింగ్ కారకం) పూర్ణాంకాలుగా ఉంటాయి. ఉదాహరణకు, 2.7 సంఖ్య 27 స్కేలింగ్ కారకం 10, 3.14 - 314 కారకం 100. అయితే, ఈ విధానం గణన కోణం నుండి చాలా ఖచ్చితమైనది కాదు, కాబట్టి, వారు తరచుగా ఫ్లోటింగ్ పాయింట్ ప్రాతినిధ్యాన్ని ఉపయోగిస్తారు. కంప్యూటింగ్‌లో, ఫ్లోటింగ్ పాయింట్ అంకగణితం అనేది పరిధి మరియు ఖచ్చితత్వం మధ్య ట్రేడ్-ఆఫ్‌కు మద్దతుగా వాస్తవ సంఖ్యల యొక్క ప్రత్యేక అంకగణిత ప్రాతినిధ్యం. జావాలో ఫ్లోటింగ్ పాయింట్ సంఖ్యలను సూచించే ప్రధాన ఆకృతిని ఫ్లోట్ అంటారు. దీని పేరు ఫ్లోటింగ్ పాయింట్ నుండి వచ్చింది. ఫ్లోట్ అనేది 32 బిట్‌లు, అందులో 1 బిట్ సైన్డ్ బిట్, 8 బిట్ ఘాతాంకానికి మరియు 23 బిట్ ప్రాముఖ్యత కోసం. దీని పరిధి ±3. 40282347E + 38F అంటే 6-7 ముఖ్యమైన అంకెలు. డబుల్ అనే పేరు డబుల్ ఫ్లోట్ నుండి వచ్చింది. దిడబుల్ టైప్ ఫ్లోట్ కంటే రెండు రెట్లు పెద్దది : 8 బైట్‌లు వర్సెస్ 4. దీనిని డబుల్ ఖచ్చితత్వ వాస్తవ సంఖ్య అని కూడా అంటారు. డబుల్ సంఖ్య కోసం రిజర్వు చేయబడిన 64 బిట్‌లలో, 1 సంతకం చేయబడిన బిట్, 11 బిట్‌లు ఘాతాంకానికి మరియు 52 బిట్‌లు ముఖ్యమైనవి. జావా డబుల్ భిన్నం ±1.79769313486231570E + 308 అంటే 15-16 ముఖ్యమైన అంకెల పరిధిలో సంఖ్యలను నిల్వ చేస్తుంది. డబుల్ అనేది మరింత ఖచ్చితమైన ఆకృతి. కాబట్టి మీరు నిజంగా పెద్ద సంఖ్యలో నిల్వ చేయవలసి ఉన్నట్లయితే, ఫ్లోట్ కంటే డబుల్‌కు ప్రాధాన్యత ఇవ్వడం మంచిది. మార్గం ద్వారా, sqrt, sin లేదా cos మరియు అనేక ఇతర గణిత పద్ధతులు డబుల్ విలువలను అందిస్తాయి. అయితే, మీరు మెమరీతో డబుల్ ఖచ్చితత్వం కోసం చెల్లించాలి.

డబుల్ వేరియబుల్ సృష్టిస్తోంది

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

double name;

పేరు అనేది వేరియబుల్ పేరు.

double myPrice;  //here we create a variable called myPrice
double action; //and here -- action. 

డబుల్ టైప్ యొక్క బహుళ వేరియబుల్‌లను సృష్టించడానికి మీరు షార్ట్‌హ్యాండ్‌ని కూడా ఉపయోగించవచ్చు :

double name1, name2, name3;

జావా డబుల్ కీవర్డ్ ఉదాహరణలు

వేరియబుల్‌ని సృష్టించడానికి జావా డబుల్ కీవర్డ్‌ని ఉపయోగించే కొన్ని ఉదాహరణలను ఇద్దాం .

double myPrice = 5.0;
double height = 180;
double x = 7.1, y = 3.0;

ఇక్కడ వేరియబుల్ myPrice లో మనకు విలువ 5.0, వేరియబుల్ ఎత్తులో — 180, x లో మనం 7.1 మరియు 3.0 విలువను y లో ఉంచుతాము .

పూర్ణాంకం వలె రెట్టింపు

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

double height = 180;
int k = 2; 
int i = 5; 
double myDouble = k*i;

వాస్తవానికి, ఎత్తు వేరియబుల్ 180.0 సంఖ్యను నిల్వ చేస్తుంది మరియు myDouble వేరియబుల్ 10.0 సంఖ్యను నిల్వ చేస్తుంది.

ద్వంద్వ మరియు పూర్ణాంక పరస్పర చర్య

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

public class DoubleDemo {
   public static void main(String[] args) {
       int k = 2;
       double myDouble1 = 5;
       double myDouble = k*7.0;
       System.out.println(myDouble1);
       System.out.println(k*myDouble1);
       System.out.println(myDouble);
   }
}

ఈ ఉదాహరణలో, అవుట్‌పుట్ ఇలా ఉంటుంది: myDouble1 సంఖ్య 5.0 కాకుండా 5గా సూచించబడినప్పటికీ, జావా ఈ సంఖ్యను డబుల్‌గా చూస్తుంది , కాబట్టి ఇది వాస్తవానికి 5.0 లాగా కనిపిస్తుంది. మనం పూర్ణం మరియు రెట్టింపు గుణిస్తే, వాస్తవానికి ఈ సంఖ్య పూర్ణాంకం అయినప్పటికీ, మనకు ఎల్లప్పుడూ డబుల్ వస్తుంది. మేము టైప్ డబుల్ టైప్ యొక్క వేరియబుల్స్ టైప్ ఇంట్ యొక్క వేరియబుల్స్‌కు కేటాయించవచ్చు . దీన్ని చేయడానికి, మీరు స్పష్టమైన రకం మార్పిడిని చేయాలి. వాస్తవానికి, పాక్షిక భాగం విస్మరించబడుతుంది, సంఖ్య చిన్న పూర్ణాంకానికి కత్తిరించబడుతుంది.

public class DoubleDemo {
   public static void main(String[] args) {
       double x = 57.789;
       int almostX;
       almostX = (int)x;
       System.out.println(almostX);
   }
}

అవుట్‌పుట్: చివరగా విభజన గురించి మాట్లాడుకుందాం. ఇది అత్యంత ఆసక్తికరమైన విషయం. మీరు రెండు పూర్ణాంకాలను భాగిస్తే, విభజన ఫలితంగా అవి ఒకదానితో ఒకటి సమానంగా భాగించబడనప్పటికీ, మనకు పూర్ణాంకం లభిస్తుందనే వాస్తవాన్ని మీరు ఇప్పటికే చూసి ఉండవచ్చు:

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7/2;
       System.out.println(myDouble);
   }
}

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

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7.0/2;
       int x = 5;
       int y = 2;
       System.out.println(myDouble);
       System.out.println(x*1.0/y);
   }
}

అవుట్‌పుట్: