Պրիմիտիվ տիպեր Java-ում

1. Պրիմիտիվ տիպերի ցանկ

Java-ում կա 8 հիմնական պրիմիտիվ տիպեր։ Պրիմիտիվ են կոչվում, որովհետև դրանց արժեքները օբյեկտ չեն և պահվում են ուղղակիորեն փոփոխականների ներսում:

Ահա աղյուսակ, որը պարունակում է կարճ տեղեկատվություն այդ տիպերի մասին:

Մեթոդների լոկալ փոփոխականները լռելյայն արժեքներ չունեն, և եթե դու այդ փոփոխականի ոչ մի արժեք չես տվել, նա կհամարվի անորոշված և նրա արժեքը օգտագործել չի կարելի։

Այնուամենայնիվ, եկեք վերադառնանք պրիմիտիվ տիպերին և մանրամասն դիտարկենք դրանք

2. Ամբողջ տիպեր

Java լեզվում կա 4 ամբողջ տիպեր՝ byte, short, int և long։ Նրանք տարբերվում են չափով և արժեքների միջակայքով, որը կարող են պահել։

Տիպ int

Հաճախ օգտագործվող տիպը int-ն է։ Դա գալիս է Integer բառից (ամբողջ թվական)։ Կոդում բոլոր ամբողջ թվային լիտերալները այս տիպն են ունենում (եթե թիվի վերջում նշված չկա L, F կամ D)։

Այս տիպով փոփոխականները կարող են ունենալ -2,147,483,648-ից մինչև +2,147,483,647 արժեքներ։

Դա բավականին մեծ է և բավարար շատ դեպքերում։ Հիմնականում բոլոր ֆունկցիաները, որոնք վերադարձնում են թիվ, վերադարձնում են int տիպի թիվ։

Օրինակներ:

int n = "Строка".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.length;

Տիպ short

Տիպ short ստացել է իր անվանումը short int-ից։ Այն կոչվում է նաև կարճ ամբողջ։ Տիպ int-ից տարբերվող նրա երկարություն ընդամենը երկու բայթ է և հնարավոր միջակայք արժեքներ ունի -32,768 մինչև +32,767:

Այսինքն, նրա մեջ նույնիսկ միլիոն չես պահի։ Նույնիսկ 50 հազար։ Սա ամենահազվադեպ օգտագործվող ամբողջ թվային տիպն է Java-ում։ Հիմնականում այն օգտագործվում է, երբ ցանկանում են խնայել հիշողությունը։

Օրինակ, եթե ունես իրավիճակ, երբ առաջադրվում է, որ աշխատում եք արժեքների հետ, որոնք չեն գերազանցում 30 հազար, իսկ այդ արժեքները բազմաթիվ են։

Օրինակ, գրում եք ծրագիր, որը մշակում է բարձր լուծաչափ ունեցող նկարներ՝ մեկ գույնի համար կիրառվում է 10 բիտ։ Իսկ նկարում ունես միլիոն էլեմենտներ։ Եվ այստեղ արդեն որոշիչ է, թե օգտագործում եք արդյոք int տիպը կամ short տիպը։

Տիպ long

Այս տիպը ստացել է իր անվանումը long int-ից՝ նրան անվանվում է նաև երկարական։ Տիպ int-ից տարբերվող նրա արդիականացված միջակայքը՝ -9*1018-ից մինչև +9*1018

Ինչու՞ հենց այն չի հանդիսանում որպես հիմնական ամբողջ թվային տիպ։

Բանն այն է, որ Java-ն ստեղծվել է դեռևս 90-ականների կեսերին, երբ համակարգիչների մեծ մասը 32-բիթային էին։ Դա նշանակում էր, որ բոլոր պրոցեսորները պատրաստ էին աշխատել 32-բիթ թվերով։ 64-բիթ ամբողջ թվերի հետ աշխատելը ևս հնարավոր էր, բայց նրանց հետ գործողություններ կատարելիս արագությունը ավելի դանդաղ է։

Արդյունքում ծրագրավորողները խելամտորեն որոշեցին ստանդարտ ամբողջ թվային տիպ դարձնել int-ը, իսկ տիպ long-ը օգտագործել միայն այն ժամանակ, երբ առանց նրա անհնար է։

Տիպ byte

Այս տիպը Java-ում ամենափոքր ամբողջ թվային տիպն է, բայց ոչ ամենահազվադեպ օգտագործվողը։ Նրա անվանումը համընկնում է byte բառի հետ՝ Java-ում նվազագույն աբխեշումային հիշողության բջիջ։

Տիպ byte-ի համար հնարավոր արժեքների չափը մեծ չէ՝ -128-ից մինչև +127, բայց ուժը սրա մեջ չէ։ Տիպ byte հիմնականում օգտագործվում է, երբ պետք է հիշողության մեջ պահել մեծ չափով անանուն տվյալների բլոկ։ Տիպ 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);   // կարդում ենք տվյալներ ֆայլից բուֆեր
   destFile.write(buffer, 0, size);      // գրում ենք տվյալներ բուֆերից ֆայլ

   // դադարեցնում ենք պատճենումը, եթե բուֆերը լիովին չի լցված
   if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();

3. Վե րականգնված տիպեր

Պրիմիտիվ տիպերի մեջ կան նաև երկուս որը կոչվում են վերականգնված։ Թեպետ սա ամբողջական անվանում չէ։ Պաշտոնապես նրանք կոչվում են վերականգնված կետային թվեր — floating point numbers։ Անվանումն առաջանում է ստանդարտից, երբ ամբողջական և վերականգնված մասերը բաժանվում են կետով (ոչ թե ստորակետով):

Java-ում երկու պրիմիտիվ վերականգնված կետային տիպ կա՝ double և float։

Ինչպես արդեն նշվեց վերև, այս տիպերը յուրահատուկ ձևով են ներքինորենավորված։ Շատ դեպքերում այս տիպերի փոփոխականների մեջ ավելացված չէ մեկ թիվ, այլ՝ երկուս՝

Օրինակ, վերականգնված միջակայք 987654.321 կարող է դիտարկվել որպես 0.987654321*106։ Հետևաբար, հիշողության մեջ այն ներկայացված կլինի որպես երկու թիվ՝ 987654321 (մանտիսիա տերզմանը՝ համարի նշանավոր մասը) և 6 (էկսպոնենտ՝ տասի աստիճանը)։

Տիպ float

Տիպ float-ի անվանումը առաջանում floating point number-ից։ Այս տիպի չափը ընդամենը փոքր է՝ ընդամենը 4 բայթ (32 բիթ), բայց այն կարող է պահել արժեքներ -3.4*1038-ից մինչև 3.4*1038: Մանտիսային դրվում են 24 բիթ, իսկ էկսպոնենտին՝ 8 բիթ։ Այս տիպը ընդամենը կարող է պահել 8 նշանավոր թվեր։

Նման մոտեցումը թույլ է տալիս պահել շատ մեծ թվեր, քան int-ը՝ օգտագործելով նույն 4 բայթերը։ Բայց դրա արժեքը մնում է ճշգրտության վրա։ Մանթիսայի պահպանման վրա ծախսվում է ավելի շատ հիշողություն, այդպիսով անմիջական թվերի քանակը ընդամենը 6-7 նշան է կետից հետո, մյուսները կձևավորվեն։

Օրինակ:

float a = (float) 123.456789;

float a = (float) 12345.9999;

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

Ինչպես տեսնում եք, այս տիպի հիմնական անկում՝ շատ փոքր նշանավոր թվերի քանակ և ճշգրտության կորուստ արդեն ութերորդ նկարի վրա։ Արդյունքում, float տիպը չի շատ համաֆրալված Java ծրագրավորողների շրջանում։

Տիպ double

Տիպ double հանդիսանում է որպես ստանդարտ վերականգնված կետային տիպ։ Անվանումը գալիս է double floating point-ից։ Այն կոչվում է նաև վերականգնված կետային թիվ երկրորդական ճշգրտություն։ Բոլոր վերականգնված լիտերալներ լռության մեջ տիպի double ունեն։

Այս տիպը զբաղեցնում է 8 բայթ հիշողություն (64 բիթ) և կարող է պահել արժեքներ -1.7*10308-ից մինչև 1.7*10308: Հիմնական գծով 53 բիթ չեն շրջանակվում, իսկ մնացած 11-ը՝ էկսպոնենտի համար։

Սա թույլ է տալիս պահել 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: Սա Not a Number-ի հապավումն է (ոչ թիվ):

Մաթեմատիկայում, եթե բաժանենք անսահմանությունը անսահմանությանը, պետք է առաջանա անորոշություն։

Դե, իսկ Java-ում, եթե բաժանենք անսահմանությունը անսահմանությանը, կստացվի 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

Պրիմիտիվ տիպերի մեջ Java-ում կա ևս մեկ, որը արժանի է հատուկ ուշադրության՝ char տիպը։ Նրա անվանումը գալիս է Character բառից, և այն օգտագործվում է նշանների պահպանի համար։

Նշաններն այս դեպքում այն են, ինչից բաղկացած են տողերը. յուրաքանչյուր տող պարունակում է նշանների զանգված։

Բայց ավելի հետաքրքրալի է այն, որ char տիպը թվային տիպ էլ է։ Այսպես, արդյունք տիպի սովորության։

Բանը այն է, որ char տիպը իրականում նշաններ չի պահում, այլ ցուցիչներ՝ նշանների համար Unicode կոդավորումից։ Յուրաքանչյուր նշանի համար կա պատասխանի թիվ․ նշանային ցուցիչ։

Յուրաքանչյուր char տիպի փոփոխականը կործվում է երկու բայթ հիշողությունում (ինչպես և short տիպը)։ Բայց short տիպի տարբերություն char տիպը՝ առանց նշանային և կարող է պահել արժեքներ 0-ից մինչև 65,535。

char տիպը հիբրիդային տիպ է։ Նրա արժեքները կարող են մեկնաբանվել և՛ որպես թվեր (դրանք կարելի է գումարել և բազմապատկել), և՛ ի որպես նշաններ։ Այսպես է կատարված, որովհետև թեպետ նշանները ունեն տեսողական ներկայացում, սակայն համակարգիչի համար նրանք նախ թիվ են։ Եվ նրանց հետ աշխատելը որպես թիվ ավելի հարմար է։

Unicode

Unicode— հատուկ աղյուսակ (կոդավորում), որը պարունակում է աշխարհի բոլոր նշանները։ Եվ յուրաքանչյուր նշանի համար կա յուր․ թիվ՝ հիշողության համար։ Սա մոտավորապես այսպես է երևում․

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。

Անձամբ, ինչը կարող եք իմանալ այս տիպի մասին, դուք արդեն գիտեք։