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

ఈ వ్యాసంలో, జావాలో లాంగ్‌ను పూర్ణాంకానికి ఎలా మార్చాలో మరియు కొన్ని కోడ్ ఉదాహరణలను ఎలా వ్రాయాలో వివరించబోతున్నాము . లాంగ్ అనేది int కంటే పెద్ద డేటా రకం కాబట్టి , ఇక్కడ మనం అటువంటి మార్పిడి కోసం టైప్ కాస్టింగ్‌ని ఉపయోగించాలి. జావాలో లాంగ్ మరియు ఇంట్ రెండూ ఆదిమ డేటా రకాలు అని మీకు ఇప్పటికే తెలుసు . అంటే అవి వర్గ వస్తువులు కావు. అన్ని ఆబ్జెక్ట్‌లు మరియు శ్రేణులు హీప్ స్పేస్‌లో నిల్వ చేయబడతాయి, అయితే పూర్ణ మరియు లాంగ్ వంటి ఆదిమ రకాలు స్టాక్ మెమరీలో నిల్వ చేయబడతాయి. పొడవు మరియు పూర్ణం కొంతవరకు సమానంగా ఉంటాయి. పూర్ణాంకం అంటే పూర్ణ సంఖ్య, అది ధనాత్మకం, ప్రతికూలం లేదా సున్నా కావచ్చు. రెండూ పొడవుమరియు int పూర్ణాంకాల రకాలు, కాబట్టి అవి ఒక విధంగా అనుకూలంగా ఉంటాయి. సమస్య ఏమిటంటే, పొడవైన రకం -263 నుండి 263 – 1 వరకు, లేదా -9223372036854775808 నుండి 9223372036854775807 వరకు ఉంటుంది. అంటే, జావా ప్రోగ్రామ్ పొడవైన రకానికి 64 బిట్‌లను కేటాయిస్తుంది . అదే సమయంలో, Int రకం 32 బిట్‌లను ఆక్రమిస్తుంది, దీనిలో మీరు -231 నుండి 231 - 1 లేదా, అదే, -2147483648 నుండి 2147483647 వరకు సంఖ్యలను ఉంచవచ్చు. దీనర్థం, ఏ సంఖ్య అయినా int రకం సులభంగా సరిపోతుంది. పొడవైన రకం. జావాలో, ఆదిమలతో పని చేస్తున్నప్పుడు, ఇరుకైన రకం నుండి విస్తృత రకానికి మార్చడం స్వయంచాలకంగా ఉంటుంది. మరొక విధంగా, దీనిని వెడల్పు అంటారు.

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

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

long myVeryLong = 10000000000l;

జావా లాంగ్ టు పూర్ణ మార్పిడి

ఇప్పుడు ఈ ఆర్టికల్ యొక్క ప్రధాన విధికి తిరిగి వెళ్దాం — జావా లాంగ్ టు ఇన్ట్ కన్వర్షన్. సమస్య ఏమిటంటే పెద్దది ఎల్లప్పుడూ చిన్నదానికి సరిపోదు. కాబట్టి ఇక్కడ మనం జావాలో స్వయంచాలకంగా “చిన్నవి”ని “పెద్దవి”గా పెట్టలేము. మేము మునుపటి ఉదాహరణలో వలె వ్యవహరించడానికి ప్రయత్నిస్తే, కానీ దీనికి విరుద్ధంగా:

//example without typecasting…nice trying! 
public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

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

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’ 
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

మేము పొడవైన విలువను పూర్ణాంక వేరియబుల్‌లో ఉంచాలనుకుంటున్నామని కంపైలర్‌కు తెలియజేసాము మరియు ఈ నిర్ణయం యొక్క పరిణామాలకు మేము బాధ్యత వహిస్తాము. కంపైలర్, ఇరుకైన రకం యొక్క స్పష్టమైన సూచనను చూసి, మార్పిడిని నిర్వహిస్తుంది. ఫలితంగా, మేము అవుట్పుట్ పొందుతాము: సరే, 16000 ఖచ్చితంగా మనం చూడాలని అనుకున్నది, అయితే -2147483648లో మైనస్ ఎందుకు? మరియు ఈ 1410065408 అంటే ఏమిటి? వాస్తవం ఏమిటంటే, అటువంటి సంఖ్యలు పొడవైన వేరియబుల్‌లో నిల్వ చేయబడ్డాయి, ఇది మనకు గుర్తున్నట్లుగా, 64 బిట్‌లను తీసుకుంటుంది. మేము ఈ సంఖ్యలను 32 బిట్‌లను మాత్రమే నిల్వ చేయగల పూర్ణాంక వేరియబుల్‌లో ఉంచడానికి ప్రయత్నిస్తున్నాము . నియమం ప్రకారం, ఈ 32 సెల్‌లు సున్నాలు మరియు పొడవైన సంఖ్య యొక్క మొదటి 32 బిట్‌ల నుండి వాటిని కలిగి ఉంటాయి మరియు మిగిలినవి విస్మరించబడతాయి. కాబట్టి, అసలు సంఖ్య 32 బిట్‌లకు సరిపోకపోతే, సరిపోని బిట్‌లు విస్మరించబడతాయి. అందుకే మనకు సరైన సంఖ్య 16000 మాత్రమే ఉంది, ఎందుకంటే ఇది 32 బిట్‌ల కంటే తక్కువ తీసుకుంటుంది.

జావా 8 పొడవు నుండి పూర్ణాంకానికి మార్పిడి

జావా 8లో, గణిత తరగతి కొత్త పద్ధతిని కలిగి ఉంది, అది పొడవును పూర్ణాంకానికి మారుస్తుంది . ఇది ఇక్కడ ఉంది:

Math.toIntExact(value);

ఈ పద్ధతి యొక్క గొప్పదనం ఏమిటంటే, ఇది మార్చబడిన సంఖ్య యొక్క పొడవును నియంత్రిస్తుంది మరియు పూర్ణాంకానికి సరిపోయేంత పెద్దదిగా ఉంటే , అది మినహాయింపును విసురుతుంది. మా ఉదాహరణలో ఇది ఎలా పని చేస్తుందో చూద్దాం:

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;
      
       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

అవుట్‌పుట్: ఈ విధంగా, ప్రోగ్రామ్ సరిగ్గా మార్చబడిన 16000 సంఖ్యను మాత్రమే ముద్రించింది, ఆపై 2147483648l పరిధి వెలుపలి సంఖ్యను పూర్ణాంకానికి నెట్టడానికి ప్రయత్నించినప్పుడు , పద్ధతి మినహాయింపును ఇచ్చింది. కాబట్టి క్లాసిక్ జావా లాంగ్ టు ఇంట్ కన్వర్షన్ విషయంలో మనకు విస్మరించిన బిట్‌ల సమస్య లేదు .