జావాలో పూర్ణాంకాన్ని డబుల్‌గా మార్చడం ఎలా

జావాలో Int మరియు డబుల్ రకాల గురించి క్లుప్తంగా

int అనేది పూర్ణాంకాల సంఖ్యల (-25, 0, 1828182845 వంటివి) కోసం ఒక ఆదిమ జావా రకం. వేరియబుల్ విలువను నిల్వ చేయడానికి ఈ రకం 32 బిట్‌లను ఉపయోగిస్తుంది. పూర్ణాంక సంఖ్యల పరిధి -231 నుండి 231 - 1 లేదా, అదే, -2147483648 నుండి 2147483647 వరకు ఉంటుంది. జావాలో డబుల్ టైప్ ఫ్లోటింగ్ పాయింట్ నంబర్‌లను సూచిస్తుంది, మెమరీలో 64 బిట్‌లను కేటాయిస్తుంది మరియు రకం పరిధి -1.7 *10308 నుండి 1.7*10308 వరకు. మీరు అదే రూపంలో పూర్ణాంక పరిధిని సూచిస్తే, అది -2*109 లేదా +2*109 అవుతుంది. డబుల్ ప్రిమిటివ్ రకానికి కేటాయించిన మెమరీకి ఎన్ని రకాల పూర్ణాంకమైనా సరిపోతుందని నేను స్పష్టంగా భావిస్తున్నాను. అదనంగా, ఏదైనా పూర్ణాంకం సున్నా భిన్న భాగంతో పాక్షిక సంఖ్యగా సూచించబడుతుంది. గణిత కోణం నుండి, ఎటువంటి సందేహం లేదు: 5 = 5.0 లేదా -57.0 = -57.

పూర్ణాన్ని రెట్టింపుగా మారుస్తోంది

జావా దృక్కోణం నుండి, డబుల్ మరియు పూర్ణాంక రకాలు కూడా అనుకూలంగా ఉంటాయి. పూర్ణాంకాన్ని డబుల్‌గా మార్చడం అనేది పెద్దది నుండి చిన్నది కాస్టింగ్ చేయడం వలన, ఈ రకమైన మార్పిడి అవ్యక్త రకం కేసింగ్ లేదా వెడల్పును పిలుస్తుంది. మీరు Int విలువను డబుల్ వేరియబుల్‌కు కేటాయించడం ద్వారా స్వయంచాలకంగా జావాలో Intని డబుల్‌గా మార్చవచ్చు. టైప్‌కాస్టింగ్ యొక్క కోడ్ ఉదాహరణను చూద్దాం:

public class intToDouble {
   public static void main(String[] args) {
       int myInt1 = 10;
       int myInt2 = 2147483647;
       double myDouble1, myDouble2;
       System.out.println("my integers are: " + myInt1 + ", " + myInt2);
       myDouble1 = myInt1;
       myDouble2 = myInt2;
       System.out.println("after typecasting/widening to double: " + myDouble1 + ", " + myDouble2);
   }
}

ఇక్కడ అవుట్‌పుట్ ఉంది: గమనికలు: ఇక్కడ E9 అంటే 109, దీనిని శాస్త్రీయ సంజ్ఞామానం అంటారు. డబుల్ సంఖ్యలు సాధారణంగా పాక్షిక భాగాన్ని వేరు చేసే వ్యవధితో వ్రాయబడతాయని కూడా గమనించండి. మీరు డబుల్ యొక్క వేరియబుల్‌ను ప్రకటించి, దానిలో విలువను ఉంచినట్లయితే, దీన్ని చేయవలసిన అవసరం లేదు, కానీ అవుట్‌పుట్‌లో డబుల్ సంఖ్య సున్నా అయినప్పటికీ, ఎల్లప్పుడూ పాక్షిక భాగాన్ని కలిగి ఉంటుంది.

న్యూట్రల్ న్యూమరికల్ ఆపరేషన్ ఉపయోగించి పూర్ణాంకాన్ని రెట్టింపుగా మార్చడం

అంతేకాకుండా, జావాలోని వివిధ రకాల వేరియబుల్స్‌పై అన్ని సంఖ్యా కార్యకలాపాలు టైప్ వైడ్‌నింగ్‌కు దారితీస్తాయి. అంటే, ఆపరేషన్ ఫలితం విస్తృత రకంగా ఉంటుంది. అందువలన, Int నుండి డబుల్కి మార్చడానికి, మీరు "తటస్థ" ఆపరేషన్ను ఉపయోగించవచ్చు. ఉదాహరణకు, పూర్ణాంకాన్ని 1.0 (డబుల్ సంఖ్య)తో గుణించండి లేదా పూర్ణాంకానికి 0.0 జోడించండి. అటువంటి టైప్‌కాస్టింగ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది:

public class intToDouble {
   public static void main(String[] args) {
       double a = 1;  //you can also write 1.0 here. If you print it out it will be 1.0
       int b = 5, x = 7;
       System.out.println(x + 0.0);
       System.out.println(a*b);
   }
}

అవుట్‌పుట్: మార్గం ద్వారా, మీరు పూర్ణాంకానికి మాత్రమే కాకుండా, అన్ని సంఖ్యా ఆదిమ రకాలను రెట్టింపుగా మార్చవచ్చు. చిన్నది నుండి పెద్దదానికి సాధ్యమయ్యే మార్పిడి క్రమం ఇక్కడ ఉంది: