1. ఆదిమ రకాల జాబితా
జావాలో 8 ప్రాథమిక ఆదిమ రకాలు ఉన్నాయి. ఈ రకాల విలువలు వస్తువులు కావు మరియు వేరియబుల్స్ లోపల నేరుగా నిల్వ చేయబడతాయి కాబట్టి వాటిని ఆదిమ అని పిలుస్తారు.
ఈ రకాల గురించి కొంత సంక్షిప్త సమాచారంతో కూడిన పట్టిక ఇక్కడ ఉంది:
టైప్ చేయండి | బైట్లలో పరిమాణం |
విలువ పరిధి | డిఫాల్ట్ విలువ | వివరణ |
---|---|---|---|---|
byte |
1 | -128 .. 127 | 0 |
అతి చిన్న పూర్ణాంకం రకం ఒకే బైట్ |
short |
2 | -32,768 .. 32.767 | 0 |
చిన్న పూర్ణాంకం, రెండు బైట్లు |
int |
4 | -2*10 9 .. 2*10 9 | 0 |
పూర్ణాంకం, 4 బైట్లు |
long |
8 | -9*10 18 .. 9*10 18 | 0L |
దీర్ఘ పూర్ణాంకం, 8 బైట్లు |
float |
4 | -10 38 .. 10 38 | 0.0f |
ఫ్లోటింగ్ పాయింట్ సంఖ్య, 4 బైట్లు |
double |
8 | -10 308 .. 10 308 | 0.0d |
డబుల్-ప్రెసిషన్ ఫ్లోటింగ్ పాయింట్ నంబర్, 8 బైట్లు |
boolean |
1 | true ,false |
false |
బూలియన్ రకం (మాత్రమే true మరియు false ) |
char |
2 | 0 .. 65.535 | '\u0000' |
అక్షరాలు, 2 బైట్లు, అన్నీ 0 కంటే ఎక్కువ |
మార్గం ద్వారా, ఇక్కడ ఒక ముఖ్యమైన సూక్ష్మభేదం ఉంది. మీరు ఇన్స్టాన్స్ వేరియబుల్ (ఫీల్డ్) లేదా స్టాటిక్ క్లాస్ వేరియబుల్ని డిక్లేర్ చేసి, దానికి వెంటనే ఏ విలువను కేటాయించకపోతే, అది డిఫాల్ట్ విలువతో ప్రారంభించబడుతుంది . పట్టిక ఈ విలువల జాబితాను ప్రదర్శిస్తుంది.
పద్ధతిలోని స్థానిక వేరియబుల్స్కు డిఫాల్ట్ విలువ ఉండదు. మీరు అటువంటి వేరియబుల్స్కు విలువను కేటాయించకపోతే, అవి ప్రారంభించబడనివిగా పరిగణించబడతాయి మరియు ఉపయోగించబడవు.
కానీ ఆదిమ రకాలకు తిరిగి వెళ్లి వాటిని నిశితంగా పరిశీలిద్దాం.
2. పూర్ణాంకాల రకాలు
జావాలో 4 పూర్ణాంకాల రకాలు ఉన్నాయి: byte
, short
, int
మరియు long
. అవి వాటి పరిమాణం మరియు నిల్వ చేయగల విలువల పరిధిలో విభిన్నంగా ఉంటాయి.
int
రకం
అత్యంత సాధారణంగా ఉపయోగించే రకం int
. ఈ పేరు పూర్ణ ఎగర్ (పూర్తి సంఖ్య) అనే పదం నుండి వచ్చింది . కోడ్లోని అన్ని పూర్ణాంకాల అక్షరాలు (పూర్తి సంఖ్యలు) (అవి ఒక , , లేదా ints
లతో ముగియకపోతే ).L
F
D
-2,147,483,648
ఈ రకమైన వేరియబుల్స్ నుండి విలువలను తీసుకోవచ్చు +2,147,483,647
.
ఇది చాలా ఎక్కువ మరియు దాదాపు ప్రతి సందర్భానికి సరిపోతుంది. సంఖ్యను అందించే దాదాపు ప్రతి ఫంక్షన్ ఒక int
.
ఉదాహరణలు:
కోడ్ | వివరణ |
---|---|
|
పద్ధతి length() స్ట్రింగ్ యొక్క పొడవును అందిస్తుంది |
|
ఫీల్డ్ length శ్రేణి పొడవును కలిగి ఉంటుంది. |
short
రకం
రకానికి short
దాని పేరు నుండి వచ్చింది short int
. దీనిని తరచుగా చిన్న పూర్ణాంకం అని కూడా అంటారు . రకం వలె కాకుండా int
, దాని పొడవు రెండు బైట్లు మాత్రమే మరియు సాధ్యమయ్యే విలువల పరిధి నుండి -32,768
వరకు ఉంటుంది +32,767
.
అంటే మీరు అందులో ఒక మిలియన్ నంబర్ను నిల్వ చేయలేరు. లేదా 50,000 కూడా. జావాలో ఇది చాలా అరుదుగా ఉపయోగించే పూర్ణాంకం రకం. దీన్ని ఉపయోగించటానికి ప్రధాన ప్రేరణ మెమరీని ఆదా చేయడం.
మీరు 30,000కు మించని విలువలతో పని చేస్తారని మరియు ఈ విలువలు మిలియన్ల కొద్దీ ఉంటాయని మీకు ముందుగానే తెలిసిన పరిస్థితిని మీరు కలిగి ఉన్నారని అనుకుందాం.
ఉదాహరణకు, మీరు ప్రతి రంగుకు -బిట్లను ఉపయోగించే అల్ట్రా-హై డెఫినిషన్ చిత్రాలను ప్రాసెస్ చేసే అప్లికేషన్ను వ్రాస్తున్నారని అనుకుందాం 10
. మరియు మీ చిత్రంలో మిలియన్ పిక్సెల్లు ఉన్నాయి. ఇది ఉపయోగించాలనే నిర్ణయం int
లేదా short
ముఖ్యమైన దృష్టాంతం.
long
రకం
ఈ రకానికి దాని పేరు వచ్చింది మరియు దీనిని దీర్ఘ పూర్ణాంకంlong int
అని కూడా పిలుస్తారు . రకం వలె కాకుండా , ఇది అద్భుతమైన అపారమైన విలువలను కలిగి ఉంది: నుండి .int
-9*1018
+9*1018
ఇది ప్రాథమిక పూర్ణాంక రకం ఎందుకు కాదు?
ఎందుకంటే జావా 90ల మధ్యలో కనిపించింది, చాలా కంప్యూటర్లు 32-బిట్గా ఉన్నప్పుడు. అంటే అన్ని ప్రాసెసర్లు 32 బిట్లతో కూడిన సంఖ్యలతో పనిచేయడానికి ఆప్టిమైజ్ చేయబడ్డాయి. ప్రాసెసర్లు 64-బిట్ పూర్ణాంకాలతో పని చేయగలవు, కానీ వాటితో కార్యకలాపాలు నెమ్మదిగా ఉంటాయి.
ఫలితంగా, ప్రోగ్రామర్లు ప్రామాణిక పూర్ణాంక రకాన్ని తయారు చేయాలని మరియు నిజంగా అవసరమైనప్పుడు మాత్రమే రకాన్ని int
ఉపయోగించాలని నిర్ణయించుకున్నారు.long
byte
రకం
ఇది జావాలో అతిచిన్న పూర్ణాంకం రకం, కానీ తక్కువ వినియోగానికి దూరంగా ఉంది. దీని పేరు, byte
, జావాలోని అతిచిన్న అడ్రస్ చేయగల మెమరీ బ్లాక్కి కూడా పదం.
రకానికి చాలా చెల్లుబాటు అయ్యే విలువలు లేవు byte
: -128
నుండి +127
. కానీ అది దాని బలం కాదు. byte
మీరు మెమరీలో పెద్ద బొట్టు డేటాను నిల్వ చేయవలసి వచ్చినప్పుడు ఈ రకం చాలా తరచుగా ఉపయోగించబడుతుంది. ఈ ప్రయోజనం కోసం s యొక్క శ్రేణి byte
అనువైనది.
మీరు ఫైల్ను ఎక్కడో కాపీ చేయవలసి ఉందని అనుకుందాం.
మీరు ఫైల్ యొక్క కంటెంట్లను ప్రాసెస్ చేయనవసరం లేదు: మీరు మెమరీని (బఫర్) సృష్టించాలి, ఫైల్లోని కంటెంట్లను దానిలోకి కాపీ చేసి, ఆపై ఆ డేటాను బఫర్ నుండి మరొక ఫైల్కి వ్రాయండి. శ్రేణి byte
మీకు దీని కోసం అవసరం.
శ్రేణి వేరియబుల్ మెమరీ ప్రాంతానికి సూచనను మాత్రమే నిల్వ చేస్తుందని గుర్తుంచుకోండి. వేరియబుల్ కొన్ని పద్ధతికి పంపబడినప్పుడు, మెమరీ చిరునామా మాత్రమే పాస్ చేయబడుతుంది. మెమరీ బ్లాక్ కూడా కాపీ చేయబడదు.
byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
int size = sourceFile.read(buffer); // Read data from a file into a buffer
destFile.write(buffer, 0, size); // Write data from the buffer to a file
// Stop copying if the buffer is not full
if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();
3. నిజమైన రకాలు
ఆదిమ రకాలు వాస్తవ సంఖ్యల కోసం రెండు రకాలను కలిగి ఉంటాయి. ఆ పదాన్ని ఉపయోగించడం పూర్తిగా ఖచ్చితమైనది కానప్పటికీ. కంప్యూటర్లు వాస్తవ సంఖ్యలను నిర్వహించినప్పుడు, మేము వాటిని ఫ్లోటింగ్ పాయింట్ నంబర్లు అని పిలుస్తాము . సంఖ్యలను సూచించే ప్రమాణం నుండి పేరు వచ్చింది, దీనిలో ఒక సంఖ్య యొక్క పూర్ణాంకం మరియు భిన్న భాగాలు ఒక కాలం (ఒక పాయింట్, కామా కాదు) ద్వారా వేరు చేయబడతాయి.
ప్రతి దేశం సంఖ్యలను వ్రాయడానికి దాని స్వంత ప్రమాణాలను కలిగి ఉంది (ఆశ్చర్యం!).
చాలా మంది వ్యక్తులు వేలను వేరు చేయడానికి మరియు కామాలను దశాంశ విభజనగా ఉపయోగించడం అలవాటు చేసుకున్నారు: ఉదాహరణకు, వారు one million ones and 153 thousandths
ఇలా వ్రాస్తారు 1.000.000,153
. కానీ జావా సృష్టికర్తలు నివసించిన యునైటెడ్ స్టేట్స్లో, భిన్నమైన ప్రమాణాన్ని స్వీకరించారు:1000000.153
జావాలో రెండు ఫ్లోటింగ్ పాయింట్ ఆదిమ రకాలు ఉన్నాయి: double
మరియు float
.
మేము ఇంతకు ముందే చెప్పినట్లుగా, ఈ రకాలు చాలా నిర్దిష్ట అంతర్గత అమరికను కలిగి ఉన్నాయి: వాస్తవానికి, ఈ రకమైన ప్రతి వేరియబుల్ లోపల ఒక సంఖ్య కాదు, రెండు:
ఉదాహరణకు, ఫ్లోటింగ్ పాయింట్ సంఖ్యను 987654.321
ఇలా సూచించవచ్చు . అప్పుడు మెమరీలో అది రెండు సంఖ్యలుగా సూచించబడుతుంది ( మాంటిస్సా , అనగా సంఖ్య యొక్క ముఖ్యమైన భాగం) మరియు ( ఘాతాంకం , అంటే పది శక్తి)0.987654321*106
987654321
6
float
రకం
రకం పేరు ఫ్లోట్ ing-పాయింట్ నంబర్float
నుండి వచ్చింది . ఈ రకం పరిమాణం చాలా చిన్నది - కేవలం 4 బైట్లు (32 బిట్లు) - కానీ ఇది నుండి విలువలను నిల్వ చేయగలదు . మాంటిస్సాను సూచించడానికి 24 బిట్లు మరియు ఘాతాంకానికి 8 బిట్లు కేటాయించబడ్డాయి. ఈ రకం 8 ముఖ్యమైన అంకెలను మాత్రమే నిల్వ చేయగలదు.-3.4*1038
3.4*1038
int
ఈ విధానం అదే 4 బైట్లను ఉపయోగిస్తున్నప్పుడు ఒక కంటే చాలా పెద్ద సంఖ్యలను నిల్వ చేయడం సాధ్యపడుతుంది . కానీ అలా చేయడానికి, మేము ఖచ్చితత్వాన్ని త్యాగం చేస్తాము. మెమరీలో కొంత భాగం మాంటిస్సాను నిల్వ చేస్తుంది కాబట్టి, ఈ వేరియబుల్స్ 6-7 దశాంశ స్థానాలను మాత్రమే నిల్వ చేస్తాయి, మిగిలినవి విస్మరించబడతాయి.
ఉదాహరణ:
కోడ్ | విలువ |
---|---|
|
123.45679 |
|
12346.0 |
|
-1.2345679 |
మీరు చూడగలిగినట్లుగా, ఈ రకం యొక్క ప్రధాన లోపం చాలా తక్కువ సంఖ్యలో ముఖ్యమైన అంకెలు, మరియు ఎనిమిదవ అంకె వెంటనే ఖచ్చితత్వం కోల్పోవడం. అందుకే float
జావా ప్రోగ్రామర్లలో ఈ రకం అంతగా ప్రాచుర్యం పొందలేదు.
double
రకం
రకం double
ప్రామాణిక ఫ్లోటింగ్ పాయింట్ రకం. ఈ పేరు డబుల్ ప్రెసిషన్ ఫ్లోటింగ్ పాయింట్ నంబర్ నుండి వచ్చింది . అన్ని నిజమైన అక్షరాలు double
డిఫాల్ట్గా ఉంటాయి.
ఈ రకం 8 బైట్ల మెమరీని తీసుకుంటుంది (64 బిట్లు) మరియు నుండి విలువలను నిల్వ చేయవచ్చు . తెలుసుకోవలసిన ముఖ్యమైన విషయం ఏమిటంటే, మాంటిస్సా కోసం 53 బిట్లు కేటాయించబడ్డాయి, మిగిలిన 11 ఘాతాంకానికి కేటాయించబడ్డాయి.-1.7*10308
1.7*10308
ఇది 15-17 ముఖ్యమైన అంకెలను నిల్వ చేయడానికి అనుమతిస్తుంది.
ఉదాహరణ:
కోడ్ | విలువ |
---|---|
|
1234567890.1234567 |
|
1234567890.1234512 |
|
1234567890.1357913 |
ఈ ఖచ్చితత్వం, ప్రత్యేకించి రకంతో పోల్చితే float
, నిర్ణయాత్మకమైనది: వాస్తవ సంఖ్యలతో అన్ని కార్యకలాపాలలో 99% double
రకాన్ని ఉపయోగించి నిర్వహించబడతాయి.
11
బిట్లు ఘాతాంకం కోసం కేటాయించబడతాయి, అంటే మీరు పది నుండి వరకు -323
( +308
అంటే రెండు నుండి -1024
వరకు +1023
) పవర్లను నిల్వ చేయవచ్చు. దశాంశ బిందువు తర్వాత ఈ double
రకం వందల సున్నాలతో సంఖ్యను సులభంగా నిల్వ చేయగలదు:
కోడ్ | విలువ |
---|---|
|
600.0 |
4. అనంతం
ఫ్లోటింగ్ పాయింట్ నంబర్లు మరొక ఆసక్తికరమైన లక్షణాన్ని కలిగి ఉన్నాయి: అవి అనంతాన్ని సూచించే ప్రత్యేక విలువను నిల్వ చేయగలవు . మరియు మీరు సానుకూల అనంతం మరియు ప్రతికూల అనంతాన్ని సూచించవచ్చు .
ఉదాహరణలు:
కోడ్ | గమనిక |
---|---|
|
|
|
|
|
|
అనంతాన్ని సంఖ్యతో గుణిస్తే, మీరు అనంతాన్ని పొందుతారు. మీరు అనంతానికి సంఖ్యను జోడిస్తే, మీరు అనంతాన్ని పొందుతారు. అది చాలా సౌకర్యవంతంగా ఉంటుంది.
సంఖ్య కాదు ( NaN
)
ఇన్ఫినిటీతో కూడిన ఏదైనా ఆపరేషన్ అనంతాన్ని ఇస్తుంది. బాగా, చాలా కానీ అన్నీ కాదు.
ఫ్లోటింగ్ పాయింట్ సంఖ్యలు మరొక ప్రత్యేక విలువను నిల్వ చేయగలవు: NaN
. ఇది N OT a N అంబెర్ (సంఖ్య కాదు)కి చిన్నది.
గణితంలో, మీరు అనంతాన్ని అనంతంతో భాగిస్తే, ఫలితం నిర్వచించబడదు.
కానీ, జావాలో, మీరు అనంతాన్ని అనంతంతో భాగిస్తే, ఫలితం NaN
.
ఉదాహరణలు:
కోడ్ | గమనిక |
---|---|
|
|
|
|
|
|
NaN
దిగుబడితో ఏదైనా ఆపరేషన్ NaN
.
5. char
రకం
జావా యొక్క ఆదిమ రకాల్లో, కొంత ప్రత్యేక శ్రద్ధ అవసరం: రకం char
. దీని పేరు చార్ యాక్టర్ అనే పదం నుండి వచ్చింది మరియు ఈ రకాన్ని అక్షరాలను నిల్వ చేయడానికి ఉపయోగిస్తారు.
అక్షరాలు అంటే తీగలను తయారు చేస్తారు, సరియైనదా? స్ట్రింగ్స్ అనేది అక్షరాల శ్రేణి.
కానీ మరింత ఆసక్తికరమైన విషయం ఏమిటంటే, ఆ char
రకం కూడా సంఖ్యా రకం ! చెప్పాలంటే ఇది ద్వంద్వ ప్రయోజన రకం.
వాస్తవమేమిటంటే, ఆ char
రకం నిజానికి అక్షరాలు కాదు. బదులుగా, ఇది యూనికోడ్ ఎన్కోడింగ్ నుండి అక్షర కోడ్లను నిల్వ చేస్తుంది. ప్రతి అక్షరం ఒక సంఖ్యకు అనుగుణంగా ఉంటుంది: పాత్ర యొక్క సంఖ్యా కోడ్.
ప్రతి char
వేరియబుల్ మెమరీలో రెండు బైట్లను ఆక్రమిస్తుంది (రకం వలె short
). కానీ short
రకం కాకుండా, char
పూర్ణాంకం రకం సంతకం చేయబడలేదు మరియు నుండి విలువలను నిల్వ 0
చేయగలదు 65,535
.
రకం char
హైబ్రిడ్ రకం. దాని విలువలను సంఖ్యలుగా (ఉదా. వాటిని జోడించి గుణించవచ్చు) మరియు అక్షరాలుగా అర్థం చేసుకోవచ్చు. అక్షరాలు దృశ్య ప్రాతినిధ్యాలు అయినప్పటికీ, కంప్యూటర్కు అవి అన్నింటికీ కేవలం సంఖ్యల కంటే ఎక్కువగా ఉంటాయి కాబట్టి ఇది జరిగింది. మరియు వారితో సంఖ్యలుగా పని చేయడం మరింత సౌకర్యవంతంగా ఉంటుంది.
యూనికోడ్
యూనికోడ్ అనేది ప్రపంచంలోని అన్ని అక్షరాలను కలిగి ఉన్న ప్రత్యేక పట్టిక (ఎన్కోడింగ్). మరియు ప్రతి పాత్రకు దాని స్వంత సంఖ్య ఉంటుంది. ఇది సుమారుగా ఇలా కనిపిస్తుంది:
వేరియబుల్కు విలువను కేటాయించడానికి వివిధ మార్గాలు ఉన్నాయి char
.
కోడ్ | వివరణ |
---|---|
|
వేరియబుల్ a లాటిన్ అక్షరాన్ని కలిగి ఉంటుంది A . |
|
వేరియబుల్ a లాటిన్ అక్షరాన్ని కలిగి ఉంటుంది A . దీని కోడ్ 65 . |
|
వేరియబుల్ a లాటిన్ అక్షరాన్ని కలిగి ఉంటుంది A . దీని కోడ్ హెక్సాడెసిమల్ సిస్టమ్లో 65 సమానం .41 |
|
వేరియబుల్ a లాటిన్ అక్షరాన్ని కలిగి ఉంటుంది A . దీని కోడ్ హెక్సాడెసిమల్ సిస్టమ్లో 65 సమానం . రెండు అదనపు సున్నాలు దేనినీ మార్చవు. 41 |
|
వేరియబుల్ a లాటిన్ అక్షరాన్ని కలిగి ఉంటుంది A . అక్షరాన్ని దాని కోడ్ ద్వారా నిర్వచించడానికి మరొక మార్గం. |
చాలా తరచుగా, వ్యక్తులు కొటేషన్ మార్కులలో అక్షరాన్ని సూచిస్తారు (టేబుల్ యొక్క మొదటి వరుసలో వలె). ఆ తరువాతి పద్ధతి కూడా ప్రజాదరణ పొందింది. దీని ప్రయోజనం ఏమిటంటే దీనిని తీగలలో ఉపయోగించవచ్చు.
మరియు మేము చెప్పినట్లుగా, char
రకం కూడా పూర్ణాంకం రకం, కాబట్టి మీరు ఇలా వ్రాయవచ్చు:
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
లాటిన్ అక్షరం B తెరపై ప్రదర్శించబడుతుంది. ఎందుకంటే : A --- 65 B _66 C 67 |
char
లతో పని చేస్తున్నారు
ప్రతి ఒక్కటి char
మొదట ఒక సంఖ్య (అక్షర కోడ్), ఆపై ఒక అక్షరం. మీకు క్యారెక్టర్ కోడ్ తెలిస్తే, మీరు ఎప్పుడైనా మీ ప్రోగ్రామ్లో క్యారెక్టర్ని పొందవచ్చు. ఉదాహరణ:
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
|
ప్రామాణిక సంకేతాలు
ఇక్కడ అత్యంత ప్రసిద్ధ అక్షర కోడ్లు ఉన్నాయి:
పాత్రలు | కోడ్లు |
---|---|
0 , 1 , 2 , ...9 |
48 , 49 , 50 , ...57 |
a , b , c , ...z |
97 , 98 , 99 , ...122 |
A , B , C , ...Z |
65 , 66 , 67 , ...90 |
6. boolean
రకం
మరియు చివరి ఆదిమ రకం boolean
.
మీకు ఇప్పటికే తెలిసినట్లుగా, ఇది రెండు విలువలను మాత్రమే తీసుకోగలదు: true
మరియు false
.
మరియు దానితో, ఈ రకం గురించి తెలుసుకోవలసిన ప్రతిదీ మీకు ఇప్పటికే తెలుసు.