పూర్ణాంకానికి మరియు పొడవుకు మధ్య తేడా
విషయము
జావాలో వివరించిన రెండు పూర్ణాంక డేటా రకాల్లో డేటా రకాలు పూర్ణాంకం మరియు పొడవు. జావాలో, int మరియు long రకాలు సంతకం చేయబడతాయి, + ve మరియు -ve విలువలు. సంతకం చేయని పూర్ణాంకానికి మరియు దీర్ఘ రకాలకు జావా మద్దతు ఇవ్వదు. పూర్ణాంకానికి మరియు పొడవైన డేటా రకానికి మధ్య ప్రాథమిక వ్యత్యాసం ప్రతి రకం యొక్క వెడల్పు. డేటాటైప్ పూర్ణాంక రకం యొక్క వేరియబుల్ కోసం 32-బిట్ యొక్క వెడల్పును కలిగి ఉంది. మరోవైపు, డేటా రకం లాంగ్ లాంగ్ టైప్ యొక్క వేరియబుల్ కోసం 64-బిట్ యొక్క వెడల్పును కలిగి ఉంటుంది. దిగువ పోలిక చార్ట్ పూర్ణాంకానికి మరియు పొడవుకు మధ్య కొన్ని ఇతర తేడాలను చూపుతుంది.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | పూర్ణాంకానికి | దీర్ఘ |
|---|---|---|
| ప్రాథమిక | డేటాటైప్ పూర్ణాంకం 32-బిట్స్. | డేటా రకం పొడవు 64-బిట్స్. |
| బైట్లు | బైట్లలో లెక్కించినట్లయితే, పూర్ణాంకానికి 4 బైట్లు. | బైట్లలో లెక్కించినట్లయితే, పొడవు 8 బైట్లు. |
| రేంజ్ | జావాలో టైప్ Int యొక్క పరిధి –2,147,483,648 నుండి 2,147,483,647. | జావాలో రకం పొడవు ఉంటుంది –9,223,372,036,854,775,808 నుండి 9,223,372,036,854,775,807. |
| కీవర్డ్ | Int రకం యొక్క వేరియబుల్ ప్రకటించడానికి ఉపయోగించే కీవర్డ్ "int". | లాంగ్ టైప్ యొక్క వేరియబుల్ డిక్లేర్ చేయడానికి ఉపయోగించే కీవర్డ్ "లాంగ్". |
| మెమరీ | పూర్ణాంకంతో పోలిస్తే పూర్ణాంక వేరియబుల్ నిల్వ చేయడానికి అవసరమైన మెమరీ తక్కువ. | Int తో పోలిస్తే లాంగ్ వేరియబుల్ నిల్వ చేయడానికి అవసరమైన మెమరీ పెద్దది. |
పూర్ణాంక రకం యొక్క నిర్వచనం
డేటా రకం పూర్ణాంకం అనేది సాధారణంగా ఉపయోగించే డేటా రకం, దీనిలో పూర్ణాంక విలువను కలిగి ఉంటుంది. పూర్ణాంక వేరియబుల్ పట్టుకోగల విలువ చాలా చిన్నది కాదు మరియు చాలా పొడవుగా ఉండదు. సాధారణంగా, పూర్ణాంక వేరియబుల్ యొక్క విలువ లూప్‌ను నియంత్రించే లూప్ వేరియబుల్‌గా ఉపయోగించబడుతుంది లేదా ఇది శ్రేణి యొక్క ఇండెక్స్ వేరియబుల్‌గా ఉపయోగించబడుతుంది. డేటా రకం పూర్ణాంకంతో పోల్చినప్పుడు డేటా రకం బైట్ మరియు షార్ట్ తక్కువ పరిధిని కలిగి ఉంటాయి, కాని పూర్ణాంక వేరియబుల్ యొక్క విలువ తక్కువ పరిధిలో ఉన్నప్పటికీ అవి పూర్ణాంకానికి భర్తీ చేయలేవు. దీని వెనుక ఉన్న కారణం ఏమిటంటే, మేము డేటా టైప్ బైట్‌ను మరియు ఎక్స్‌ప్రెషన్‌లో చిన్నదాన్ని ఉపయోగించినప్పుడు, ఆ వ్యక్తీకరణను అంచనా వేసేటప్పుడు డేటా రకం బైట్ మరియు షార్ట్ కంపైలర్ చేత పూర్ణాంకానికి ప్రచారం చేయబడతాయి. కాబట్టి, దీని నుండి, పూర్ణాంకం అవసరమైన చోట పూర్ణాంకానికి ఉపయోగించడం మంచిది అని చెప్పవచ్చు.
Int డేటాటైప్ వాడకాన్ని చూద్దాం.
బైట్ a = 70; బైట్ బి = 80; int c = a * b; // లోపం లేదు. బైట్ d = a + 10; // కంపైల్ టైమ్ ఎర్రర్.
పై కోడ్‌లో మీరు గమనించినట్లుగా, బైట్ వేరియబుల్స్ a మరియు b విలువ 70 మరియు 80 కలిగివుంటాయి, ఇది చెల్లుబాటు అయ్యే బైట్-శ్రేణి విలువ. కానీ, a * b యొక్క ఇంటర్మీడియట్ ఫలితం; బైట్ యొక్క పరిమితిని మించిపోయింది. అందువల్ల, కంపైలర్ స్వయంచాలకంగా బైట్, షార్ట్ మరియు చార్ వేరియబుల్స్ ను వ్యక్తీకరణలో ఉపయోగించినట్లయితే పూర్ణాంకానికి టైప్ చేయడానికి ప్రోత్సహిస్తుంది. ఇప్పుడు, * b యొక్క ఫలితం ఒక పూర్ణాంక వేరియబుల్‌కు కేటాయించబడిందని మీరు చూడవచ్చు, ఇది ఎటువంటి లోపం కలిగించదు మరియు సజావుగా కంపైల్ చేస్తుంది ఎందుకంటే a మరియు b వేరియబుల్స్ టైప్ పూర్ణాంకానికి ప్రచారం చేయబడతాయి మరియు టైప్ Int యొక్క టైప్ int యొక్క కేటాయింపు int కు ఇవ్వదు ' t లోపం కలిగిస్తుంది.
కోడ్ యొక్క చివరి పంక్తిలో, మీరు ఒక వ్యక్తీకరణను చూడవచ్చు, ఇక్కడ విలువ 10 బైట్ వేరియబుల్‌కు జోడించబడుతుంది ‘a’ దాని ఫలితం ఇప్పటికీ బైట్ యొక్క పరిమితిని మించలేదు. కానీ, బైట్ వేరియబుల్ ‘d’ కు “a + 10” వ్యక్తీకరణ యొక్క ఇంటర్మీడియట్ ఫలితం యొక్క కేటాయింపు కంపైల్ టైమ్ లోపానికి కారణమవుతుంది ఎందుకంటే వ్యక్తీకరణ మూల్యాంకనం బైట్ వేరియబుల్ ‘a’ టైప్ Int కి ప్రచారం చేయబడుతుంది. మరియు బైట్ టైప్ చేయడానికి టైప్ Int యొక్క కేటాయింపు అనుమతించబడదు. అందువల్ల, ఇది కంపైల్ సమయ లోపానికి కారణమవుతుంది.
దీర్ఘ రకం యొక్క నిర్వచనం
బైట్, షార్ట్ మరియు పూర్ణాంక రకాలతో పోలిస్తే డేటా రకం పొడవు అతిపెద్ద పరిధి మరియు వెడల్పును కలిగి ఉంటుంది. జావాలో, పొడవు రకం 64-బిట్ సంతకం చేసిన పూర్ణాంక రకం. కావలసిన విలువను కలిగి ఉండటానికి Int రకం పెద్దది కానప్పుడు టైప్ లాంగ్ ఉపయోగించబడుతుంది. పెద్ద పరిధి -9,223,372,036,854,775,808 నుండి 9,223,372,036,854,775,807 ఇది చాలా పెద్దది, పెద్ద మొత్తం సంఖ్యల వంటి పెద్ద విలువలను కలిగి ఉండటానికి. దిగువ ఉదాహరణతో మనం రకాన్ని దీర్ఘంగా అర్థం చేసుకోవచ్చు.
తరగతి బరువు {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్) {int అంశం; int wt_per_item; పొడవైన గ్రాములు; పొడవైన పెట్టె; అంశం = 10000000; // సంఖ్య అంశాలను పేర్కొనండి wt_per_item = 10000; // ఒక వస్తువు బరువును కిలో గ్రాములలో పేర్కొనండి = wt_item * 1000; // బరువును గ్రాముగా మార్చండి బాక్స్ = అంశం * గ్రాములు; // గ్రాముల బాక్స్ బరువును లెక్కించండి System.out.ln ("అంశం సంఖ్య" + అంశం); System.out.ln ("ప్రతి వస్తువుకు బరువు" + wt_per_item + "కిలోలు"); System.out.ln ("గ్రాములో పెట్టె బరువు" + బాక్స్ + "కిలోలు"); Item item అంశం సంఖ్య 10000000 వస్తువుకు బరువు 10000 కిలోలు గ్రాములో పెట్టె బరువు 100000000000000 కిలోలు
పై కోడ్‌లో అవుట్‌పుట్‌ను గమనించండి; ఫలితం 10000000 వస్తువులను కలిగి ఉన్న పెట్టెను కలిగి ఉన్న మొత్తం పెట్టె యొక్క బరువు కోసం లెక్కించబడుతుంది, వీటిలో ప్రతి వస్తువు బరువు 10000 కిలోలు. గ్రాముల పెట్టె బరువుకు కంప్యూటెడ్ విలువ, పూర్ణాంక వేరియబుల్ ద్వారా ఉంచబడదు. అందువల్ల, పెద్ద విలువలను లెక్కించేటప్పుడు లేదా పట్టుకున్నప్పుడు కొన్నిసార్లు దీర్ఘ రకాన్ని ఉపయోగించడం అవసరం అవుతుంది.
- Int రకం మరియు పొడవు మధ్య ప్రాథమిక వ్యత్యాసం వాటి వెడల్పు, ఇక్కడ int 32 బిట్, మరియు పొడవు 64 బిట్స్.
- బిట్లకు బదులుగా బైట్లలో లెక్కించినప్పుడు పూర్ణాంకం మరియు పొడవు రకాలు 4 బైట్లు మరియు టైప్ లాంగ్ టైప్ ఉంటే రెండు రెట్లు ఉంటుంది, అంటే 8 బైట్లు.
- జావాలో, టైప్ Int యొక్క పరిధి –2,147,483,648 నుండి 2,147,483,647 వరకు ఉండగా, టైప్ లాంగ్ యొక్క పరిధి –9,223,372,036,854,775,808 నుండి 9,223,372,036,854,775,807 వరకు ఉంది, ఇది టైప్ Int కంటే చాలా ఎక్కువ.
- Int రకం యొక్క వేరియబుల్ ప్రకటించడానికి ఉపయోగించే కీవర్డ్ “int”. మరోవైపు, టైప్ లాంగ్ యొక్క వేరియబుల్‌ను ప్రకటించడానికి ఉపయోగించే కీవర్డ్ “లాంగ్”.
- సాధారణంగా, టైప్ పూర్ణాంక విలువను పట్టుకోవటానికి అవసరమైన మెమరీ పొడవుతో పోలిస్తే తక్కువగా ఉంటుంది.
ముగింపు:
మీడియం రేంజ్ విలువ అవసరమైతే కోడ్ వ్రాసేటప్పుడు మీరు టైప్ Int ను ఉపయోగించవచ్చు, కానీ ఏదైనా వ్యక్తీకరణ ద్వారా ఉత్పత్తి అవుతున్న పెద్దది లేదా పెద్ద విలువలు గణన కోసం ఉపయోగించబడుతున్నప్పుడు లాంగ్ టైప్ వేరియబుల్ పట్టుకోవాలి విలువలు.
