జావాలో ఆదిమ రకాలు

1. ఆదిమ రకాల జాబితా

జావాలో 8 ప్రాథమిక ఆదిమ రకాలు ఉన్నాయి. ఈ రకాల విలువలు వస్తువులు కావు మరియు వేరియబుల్స్ లోపల నేరుగా నిల్వ చేయబడతాయి కాబట్టి వాటిని ఆదిమ అని పిలుస్తారు.

ఈ రకాల గురించి కొంత సంక్షిప్త సమాచారంతో కూడిన పట్టిక ఇక్కడ ఉంది:

పద్ధతిలోని స్థానిక వేరియబుల్స్‌కు డిఫాల్ట్ విలువ ఉండదు. మీరు అటువంటి వేరియబుల్స్‌కు విలువను కేటాయించకపోతే, అవి ప్రారంభించబడనివిగా పరిగణించబడతాయి మరియు ఉపయోగించబడవు.

కానీ ఆదిమ రకాలకు తిరిగి వెళ్లి వాటిని నిశితంగా పరిశీలిద్దాం.

2. పూర్ణాంకాల రకాలు

జావాలో 4 పూర్ణాంకాల రకాలు ఉన్నాయి: byte, short, intమరియు long. అవి వాటి పరిమాణం మరియు నిల్వ చేయగల విలువల పరిధిలో విభిన్నంగా ఉంటాయి.

intరకం

అత్యంత సాధారణంగా ఉపయోగించే రకం int. ఈ పేరు పూర్ణ ఎగర్ (పూర్తి సంఖ్య) అనే పదం నుండి వచ్చింది . కోడ్‌లోని అన్ని పూర్ణాంకాల అక్షరాలు (పూర్తి సంఖ్యలు) (అవి ఒక , , లేదా intsలతో ముగియకపోతే ).LFD

-2,147,483,648ఈ రకమైన వేరియబుల్స్ నుండి విలువలను తీసుకోవచ్చు +2,147,483,647.

ఇది చాలా ఎక్కువ మరియు దాదాపు ప్రతి సందర్భానికి సరిపోతుంది. సంఖ్యను అందించే దాదాపు ప్రతి ఫంక్షన్ ఒక int.

ఉదాహరణలు:

int n = "String".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.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. నిజమైన రకాలు

ఆదిమ రకాలు వాస్తవ సంఖ్యల కోసం రెండు రకాలను కలిగి ఉంటాయి. ఆ పదాన్ని ఉపయోగించడం పూర్తిగా ఖచ్చితమైనది కానప్పటికీ. కంప్యూటర్లు వాస్తవ సంఖ్యలను నిర్వహించినప్పుడు, మేము వాటిని ఫ్లోటింగ్ పాయింట్ నంబర్లు అని పిలుస్తాము . సంఖ్యలను సూచించే ప్రమాణం నుండి పేరు వచ్చింది, దీనిలో ఒక సంఖ్య యొక్క పూర్ణాంకం మరియు భిన్న భాగాలు ఒక కాలం (ఒక పాయింట్, కామా కాదు) ద్వారా వేరు చేయబడతాయి.

జావాలో రెండు ఫ్లోటింగ్ పాయింట్ ఆదిమ రకాలు ఉన్నాయి: doubleమరియు float.

మేము ఇంతకు ముందే చెప్పినట్లుగా, ఈ రకాలు చాలా నిర్దిష్ట అంతర్గత అమరికను కలిగి ఉన్నాయి: వాస్తవానికి, ఈ రకమైన ప్రతి వేరియబుల్ లోపల ఒక సంఖ్య కాదు, రెండు:

ఉదాహరణకు, ఫ్లోటింగ్ పాయింట్ సంఖ్యను 987654.321ఇలా సూచించవచ్చు . అప్పుడు మెమరీలో అది రెండు సంఖ్యలుగా సూచించబడుతుంది ( మాంటిస్సా , అనగా సంఖ్య యొక్క ముఖ్యమైన భాగం) మరియు ( ఘాతాంకం , అంటే పది శక్తి)0.987654321*1069876543216

floatరకం

రకం పేరు ఫ్లోట్ ing-పాయింట్ నంబర్float నుండి వచ్చింది . ఈ రకం పరిమాణం చాలా చిన్నది - కేవలం 4 బైట్లు (32 బిట్‌లు) - కానీ ఇది నుండి విలువలను నిల్వ చేయగలదు . మాంటిస్సాను సూచించడానికి 24 బిట్‌లు మరియు ఘాతాంకానికి 8 బిట్‌లు కేటాయించబడ్డాయి. ఈ రకం 8 ముఖ్యమైన అంకెలను మాత్రమే నిల్వ చేయగలదు.-3.4*10383.4*1038

intఈ విధానం అదే 4 బైట్‌లను ఉపయోగిస్తున్నప్పుడు ఒక కంటే చాలా పెద్ద సంఖ్యలను నిల్వ చేయడం సాధ్యపడుతుంది . కానీ అలా చేయడానికి, మేము ఖచ్చితత్వాన్ని త్యాగం చేస్తాము. మెమరీలో కొంత భాగం మాంటిస్సాను నిల్వ చేస్తుంది కాబట్టి, ఈ వేరియబుల్స్ 6-7 దశాంశ స్థానాలను మాత్రమే నిల్వ చేస్తాయి, మిగిలినవి విస్మరించబడతాయి.

ఉదాహరణ:

float a = (float) 123.456789;

float a = (float) 12345.9999;

float a = (float) -123.456789E-2;

మీరు చూడగలిగినట్లుగా, ఈ రకం యొక్క ప్రధాన లోపం చాలా తక్కువ సంఖ్యలో ముఖ్యమైన అంకెలు, మరియు ఎనిమిదవ అంకె వెంటనే ఖచ్చితత్వం కోల్పోవడం. అందుకే floatజావా ప్రోగ్రామర్లలో ఈ రకం అంతగా ప్రాచుర్యం పొందలేదు.

doubleరకం

రకం doubleప్రామాణిక ఫ్లోటింగ్ పాయింట్ రకం. ఈ పేరు డబుల్ ప్రెసిషన్ ఫ్లోటింగ్ పాయింట్ నంబర్ నుండి వచ్చింది . అన్ని నిజమైన అక్షరాలు doubleడిఫాల్ట్‌గా ఉంటాయి.

ఈ రకం 8 బైట్‌ల మెమరీని తీసుకుంటుంది (64 బిట్‌లు) మరియు నుండి విలువలను నిల్వ చేయవచ్చు . తెలుసుకోవలసిన ముఖ్యమైన విషయం ఏమిటంటే, మాంటిస్సా కోసం 53 బిట్‌లు కేటాయించబడ్డాయి, మిగిలిన 11 ఘాతాంకానికి కేటాయించబడ్డాయి.-1.7*103081.7*10308

ఇది 15-17 ముఖ్యమైన అంకెలను నిల్వ చేయడానికి అనుమతిస్తుంది.

ఉదాహరణ:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

ఈ ఖచ్చితత్వం, ప్రత్యేకించి రకంతో పోల్చితే float, నిర్ణయాత్మకమైనది: వాస్తవ సంఖ్యలతో అన్ని కార్యకలాపాలలో 99% doubleరకాన్ని ఉపయోగించి నిర్వహించబడతాయి.

11బిట్‌లు ఘాతాంకం కోసం కేటాయించబడతాయి, అంటే మీరు పది నుండి వరకు -323( +308అంటే రెండు నుండి -1024వరకు +1023) పవర్‌లను నిల్వ చేయవచ్చు. దశాంశ బిందువు తర్వాత ఈ doubleరకం వందల సున్నాలతో సంఖ్యను సులభంగా నిల్వ చేయగలదు:

double a = 2E-300 * 3E+302

4. అనంతం

ఫ్లోటింగ్ పాయింట్ నంబర్‌లు మరొక ఆసక్తికరమైన లక్షణాన్ని కలిగి ఉన్నాయి: అవి అనంతాన్ని సూచించే ప్రత్యేక విలువను నిల్వ చేయగలవు . మరియు మీరు సానుకూల అనంతం మరియు ప్రతికూల అనంతాన్ని సూచించవచ్చు .

ఉదాహరణలు:

System.out.println( 100.0 / 0.0 );

Infinity

System.out.println( -100.0 / 0.0 );

-Infinity

double a = 1d / 0d;
double b = a * 10;
double c = b - 100;

a == Infinity
b == Infinity
c == Infinity

అనంతాన్ని సంఖ్యతో గుణిస్తే, మీరు అనంతాన్ని పొందుతారు. మీరు అనంతానికి సంఖ్యను జోడిస్తే, మీరు అనంతాన్ని పొందుతారు. అది చాలా సౌకర్యవంతంగా ఉంటుంది.

సంఖ్య కాదు ( NaN)

ఇన్ఫినిటీతో కూడిన ఏదైనా ఆపరేషన్ అనంతాన్ని ఇస్తుంది. బాగా, చాలా కానీ అన్నీ కాదు.

ఫ్లోటింగ్ పాయింట్ సంఖ్యలు మరొక ప్రత్యేక విలువను నిల్వ చేయగలవు: NaN. ఇది N OT a N అంబెర్ (సంఖ్య కాదు)కి చిన్నది.

గణితంలో, మీరు అనంతాన్ని అనంతంతో భాగిస్తే, ఫలితం నిర్వచించబడదు.

కానీ, జావాలో, మీరు అనంతాన్ని అనంతంతో భాగిస్తే, ఫలితం NaN.

ఉదాహరణలు:

System.out.println(0.0 / 0.0);

NaN

double infinity = 1d / 0d;
System.out.println(infinity / infinity);

NaN

double a = 0.0 / 0.0;
double b = a * 10;
double c = b - 100;
double d = a + infinity;

a == NaN
b == NaN
c == NaN
d == NaN

NaNదిగుబడితో ఏదైనా ఆపరేషన్ NaN.

5. charరకం

జావా యొక్క ఆదిమ రకాల్లో, కొంత ప్రత్యేక శ్రద్ధ అవసరం: రకం char. దీని పేరు చార్ యాక్టర్ అనే పదం నుండి వచ్చింది మరియు ఈ రకాన్ని అక్షరాలను నిల్వ చేయడానికి ఉపయోగిస్తారు.

అక్షరాలు అంటే తీగలను తయారు చేస్తారు, సరియైనదా? స్ట్రింగ్స్ అనేది అక్షరాల శ్రేణి.

కానీ మరింత ఆసక్తికరమైన విషయం ఏమిటంటే, ఆ charరకం కూడా సంఖ్యా రకం ! చెప్పాలంటే ఇది ద్వంద్వ ప్రయోజన రకం.

వాస్తవమేమిటంటే, ఆ charరకం నిజానికి అక్షరాలు కాదు. బదులుగా, ఇది యూనికోడ్ ఎన్‌కోడింగ్ నుండి అక్షర కోడ్‌లను నిల్వ చేస్తుంది. ప్రతి అక్షరం ఒక సంఖ్యకు అనుగుణంగా ఉంటుంది: పాత్ర యొక్క సంఖ్యా కోడ్.

ప్రతి charవేరియబుల్ మెమరీలో రెండు బైట్‌లను ఆక్రమిస్తుంది (రకం వలె short). కానీ shortరకం కాకుండా, charపూర్ణాంకం రకం సంతకం చేయబడలేదు మరియు నుండి విలువలను నిల్వ 0చేయగలదు 65,535.

రకం charహైబ్రిడ్ రకం. దాని విలువలను సంఖ్యలుగా (ఉదా. వాటిని జోడించి గుణించవచ్చు) మరియు అక్షరాలుగా అర్థం చేసుకోవచ్చు. అక్షరాలు దృశ్య ప్రాతినిధ్యాలు అయినప్పటికీ, కంప్యూటర్‌కు అవి అన్నింటికీ కేవలం సంఖ్యల కంటే ఎక్కువగా ఉంటాయి కాబట్టి ఇది జరిగింది. మరియు వారితో సంఖ్యలుగా పని చేయడం మరింత సౌకర్యవంతంగా ఉంటుంది.

యూనికోడ్

యూనికోడ్ అనేది ప్రపంచంలోని అన్ని అక్షరాలను కలిగి ఉన్న ప్రత్యేక పట్టిక (ఎన్‌కోడింగ్). మరియు ప్రతి పాత్రకు దాని స్వంత సంఖ్య ఉంటుంది. ఇది సుమారుగా ఇలా కనిపిస్తుంది:

వేరియబుల్‌కు విలువను కేటాయించడానికి వివిధ మార్గాలు ఉన్నాయి char.

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

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

మరియు మేము చెప్పినట్లుగా, charరకం కూడా పూర్ణాంకం రకం, కాబట్టి మీరు ఇలా వ్రాయవచ్చు:

char a = 'A';
a++;
System.out.println(a);

charలతో పని చేస్తున్నారు

ప్రతి ఒక్కటి charమొదట ఒక సంఖ్య (అక్షర కోడ్), ఆపై ఒక అక్షరం. మీకు క్యారెక్టర్ కోడ్ తెలిస్తే, మీరు ఎప్పుడైనా మీ ప్రోగ్రామ్‌లో క్యారెక్టర్‌ని పొందవచ్చు. ఉదాహరణ:

char c = (char) 1128;
System.out.println(c);

Ѩ

ప్రామాణిక సంకేతాలు

ఇక్కడ అత్యంత ప్రసిద్ధ అక్షర కోడ్‌లు ఉన్నాయి:

6. booleanరకం

మరియు చివరి ఆదిమ రకం boolean.

మీకు ఇప్పటికే తెలిసినట్లుగా, ఇది రెండు విలువలను మాత్రమే తీసుకోగలదు: trueమరియు false.

మరియు దానితో, ఈ రకం గురించి తెలుసుకోవలసిన ప్రతిదీ మీకు ఇప్పటికే తెలుసు.