ఈ కథనం జావాలో 'లాంగ్' ను 'ఇంట్'గా మార్చడం గురించి వివరిస్తుంది.
జావాలో 'లాంగ్' మరియు 'ఇంట్' అంటే ఏమిటి?
ది ' పొడవు 'జావా పరిధిలో టైప్ చేయండి' -9223372036854775808 ' నుండి ' 922337203685477580 'మరియు కేటాయించబడింది' 64 ” బిట్స్. ది ' int 'టైప్, అయితే, ఆక్రమిస్తుంది' 32 'బిట్‌లు' నుండి -2147483648 ' నుండి ' 2147483647 ”. ఇది ఏదైనా సంఖ్యను సూచిస్తుంది int ' రకాలను సులభంగా సపోర్ట్ చేయవచ్చు ' పొడవు ”అని టైప్ చేయండి కానీ ఇది చాలా సందర్భాలలో ఎప్పుడూ ఉండదు.
జావాను ఉపయోగించి 'లాంగ్' నుండి 'ఇంట్' కు ఎలా మార్చాలి?
మార్చడానికి ' పొడవు ' నుండి ' int ” జావాలో, కింది విధానాలను వర్తింపజేయండి:
విధానం 1: “Math.toIntExact()” పద్ధతిని ఉపయోగించి జావాలో లాంగ్‌ను పూర్ణాంకానికి మార్చండి
ది ' Math.toIntExact() జావాలో “పద్ధతి” ఇస్తుంది int 'అందించిన దాని నుండి విలువ' పొడవు ” వాదన. ఈ పద్ధతిని కేవలం పాస్ చేయడానికి అన్వయించవచ్చు ' పొడవు ” విలువను దాని ఆర్గ్యుమెంట్‌గా మరియు పూర్ణాంకంగా తిరిగి ఇవ్వండి.
వాక్యనిర్మాణం
గణితం . IntExact కు ( పొడవు విలువ )
ఈ వాక్యనిర్మాణంలో, ' దీర్ఘ విలువ ” అనేది తిరిగి ఇవ్వాల్సిన విలువను సూచిస్తుంది int ”.
ఉదాహరణ
కింది ఉదాహరణను స్థూలంగా చూద్దాం:
ప్రజా తరగతి లాంగ్‌టోయింట్2 {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
పొడవు ఎంపిక 1 = 8624675L ;
పొడవు విలువ 2 = 3482398L ;
int నవీకరణVal1 = గణితం . IntExact కు ( ఎంపిక 1 ) ;
int updVal2 = గణితం . IntExact కు ( విలువ 2 ) ;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + నవీకరణVal1 ) ;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + updVal2 ) ;
}
}
ఈ కోడ్ స్నిప్పెట్‌లో, ఈ క్రింది దశలను చేయండి:
- మొదట, రెండింటిని ప్రారంభించండి ' పొడవు 'విలువలు.
- గమనిక: పేర్కొన్న ' ఎల్ విలువలలో 'ని సూచిస్తాయి మరియు వేరు చేస్తాయి' పొడవు 'విలువలు' నుండి int 'విలువలు.
- ఆ తరువాత, వర్తించు ' Math.toIntExact() ”పద్ధతి రెండుసార్లు మరియు ప్రారంభించబడిన దీర్ఘ విలువలు రెండింటినీ పూర్ణాంకాలుగా మార్చడానికి దాని పరామితిగా సేకరించండి.
- చివరగా, కన్సోల్‌లో మార్చబడిన పూర్ణాంక విలువలను లాగ్ చేయండి.
అవుట్‌పుట్
పై ఫలితంలో, సంబంధిత పూర్ణాంక విలువలు ప్రదర్శించబడతాయని విశ్లేషించవచ్చు.
గమనిక: '' విలువ ఉన్నప్పుడు మార్పిడి (దీర్ఘంగా పూర్ణాంకానికి) ప్రక్రియ బాగా పనిచేస్తుంది పొడవు '' గరిష్ట విలువ కంటే తక్కువ లేదా సమానం int ”, అంటే, (2147483647). ఇతర సందర్భంలో, ఒక లోపం ఎదుర్కొంది మరియు డేటా నష్టం కూడా ఉండవచ్చు.
ప్రదర్శన
పరిమితికి దారితీసే చర్చించబడిన భావనను గమనించండి:
పై ఉదాహరణలో, రెండవదాన్ని పెంచండి ' పొడవు ” విలువ మరియు మార్పిడిని నిర్వహించండి. ఇది ఎదుర్కోవటానికి దారి తీస్తుంది ' పూర్ణాంకం ఓవర్‌ఫ్లో 'పరివర్తించబడిన విలువ 'ని మించిపోయింది కాబట్టి పరిమితి int 'గరిష్ట పరిమితి.
విధానం 2: 'ఇరుకైన టైప్‌కాస్టింగ్'ని ఉపయోగించి జావాలో లాంగ్‌ను పూర్ణాంకానికి మార్చండి
' టైప్ కాస్టింగ్ ” ఒక ఆదిమ డేటా రకం విలువను మరొకదానికి కేటాయించడానికి అనుగుణంగా ఉంటుంది. ఈ సందర్భంలో, ' ఇరుకైన టైప్‌కాస్టింగ్ 'అధిక డేటా రకం నుండి అమలులోకి వస్తుంది, అనగా,' పొడవు 'తక్కువ డేటా రకంగా మార్చబడింది' int ”. మార్చవలసిన విలువను కుండలీకరణాల్లో కావలసిన రకాన్ని ఉంచడం ద్వారా దీన్ని సాధించవచ్చు.
ఉదాహరణ
కింది ఉదాహరణ చర్చించబడిన భావనను వివరిస్తుంది:
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
పొడవు ఎంపిక 1 = 647467L ;
పొడవు విలువ 2 = 348 239L ;
int నవీకరణVal1 = ( int ) ఎంపిక 1 ;
int updVal2 = ( int ) విలువ 2 ;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + నవీకరణVal1 ) ;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + updVal2 ) ;
}
}
పై కోడ్ లైన్లలో:
- అదేవిధంగా, రెండింటిని ప్రారంభించండి ' పొడవు 'విలువలు.
- తదుపరి దశలో, “ని వర్తింపజేయండి ఇరుకైన టైప్‌కాస్టింగ్ 'మార్చవలసిన విలువను ఉంచడం ద్వారా కావలసిన రకాన్ని అనుసరించి, అంటే,' int ”.
- చివరగా, మార్చబడిన “ని ప్రదర్శించండి int ”కన్సోల్‌లో విలువలు.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, ' పొడవు 'విలువలు' గా మార్చబడతాయి int ” విలువలు, తగిన విధంగా.
విధానం 3: “intValue()” పద్ధతిని ఉపయోగించి జావాలో పొడవైన వస్తువును పూర్ణాంకానికి మార్చండి
ది ' intValue() 'జావాలో పద్ధతి అనుబంధ సంఖ్య యొక్క విలువను' రూపంలో అందిస్తుంది int ”. అనుబంధిత పొడవాటిని మార్చడానికి ఈ పద్ధతిని అమలు చేయవచ్చు ' వస్తువులు ”పూర్ణాంకాలలోకి.
ఉదాహరణ
మార్పిడిని నిర్వహించడానికి దిగువ అందించిన ఉదాహరణను చూడండి:
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
దీర్ఘ విలువ 1 = కొత్త పొడవు ( 8624675L ) ;
దీర్ఘ విలువ 2 = కొత్త పొడవు ( 3482398L ) ;
int నవీకరణVal1 = ఎంపిక 1. intvalue ( ) ;
int updVal2 = విలువ 2. intvalue ( ) ;;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + నవీకరణVal1 ) ;
వ్యవస్థ. బయటకు . println ( 'పూర్ణాంకం విలువ:' + updVal2 ) ;
}
}
పై కోడ్ బ్లాక్‌లో:
- అన్నింటిలో మొదటిది, రెండింటిని సృష్టించండి ' పొడవు '' ద్వారా వస్తువులు కొత్త 'కీవర్డ్ మరియు' పొడవైన() ” కన్స్ట్రక్టర్, వరుసగా.
- కన్స్ట్రక్టర్ పారామితులలో, ''గా మార్చవలసిన పొడవైన విలువలను పేర్కొనండి int ”.
- ఇప్పుడు, అనుబంధించండి ' intValue() 'సృష్టించిన రెండు వస్తువులతో కూడిన పద్ధతి మరియు సేకరించిన వాటిని మార్చండి' పొడవు 'విలువలు' లోకి పూర్ణాంకాలు ” మరియు వాటిని ప్రదర్శించండి.
అవుట్‌పుట్
పై ఫలితం ఆబ్జెక్ట్ విలువలు ''గా మార్చబడతాయని సూచిస్తుంది పూర్ణాంకాలు ” తగిన విధంగా.
ముగింపు
జావాలో లాంగ్‌ను పూర్ణాంకానికి మార్చడానికి, “ని వర్తింపజేయండి Math.toIntExact() 'పద్ధతి,' ఇరుకైన టైప్‌కాస్టింగ్ 'విధానం, లేదా' intValue() ” పద్ధతి. ఈ విధానాలు ప్రారంభించబడిన దీర్ఘ విలువ మరియు ఆబ్జెక్ట్‌ను పూర్ణాంకంగా మారుస్తాయి ' పొడవు 'మార్పిడి చేయవలసిన విలువ' గరిష్ట విలువను మించదు int ”. ఈ బ్లాగ్ జావాను ఉపయోగించి లాంగ్‌ను పూర్ణాంకానికి మార్చడానికి మార్గనిర్దేశం చేయబడింది.