Mga primitive na uri sa Java

1. Listahan ng mga primitive na uri

Ang Java ay may 8 pangunahing primitive na uri. Tinatawag silang primitive dahil ang mga halaga ng mga ganitong uri ay hindi mga bagay at direktang nakaimbak sa loob ng mga variable.

Narito ang isang talahanayan na may ilang maikling impormasyon tungkol sa mga ganitong uri:

Ang mga lokal na variable sa isang paraan ay walang default na halaga. Kung hindi ka magtatalaga ng halaga sa mga naturang variable, ituturing ang mga ito na hindi nasimulan at hindi magagamit.

Ngunit bumalik tayo sa mga primitive na uri at tingnang mabuti ang mga ito.

2. Mga uri ng integer

Ang Java ay may 4 na uri ng integer: byte, short, intat long. Magkaiba ang mga ito sa kanilang laki at sa hanay ng mga halaga na maaari nilang iimbak.

inturi

Ang pinakakaraniwang ginagamit ay ang inturi. Ang pangalan ay nagmula sa salitang int eger (buong bilang). Ang lahat ng integer literal (buong mga numero) sa code ay ints(kung hindi sila nagtatapos sa isang L, F, o D).

Ang mga variable ng ganitong uri ay maaaring tumagal ng mga halaga mula -2,147,483,648hanggang +2,147,483,647.

Marami iyon at sapat na para sa halos lahat ng okasyon. Halos bawat function na nagbabalik ng isang numero ay nagbabalik ng isang int.

Mga halimbawa:

int n = "String".length();

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

shorturi

Ang shorturi ay nakuha ang pangalan nito mula sa short int. Madalas din itong tinatawag na short integer . Hindi tulad ng inturi, ang haba nito ay dalawang byte lamang at ang hanay ng mga posibleng halaga ay mula -32,768hanggang +32,767.

Ibig sabihin, hindi mo maiimbak ang numerong isang milyon dito. O kahit 50,000. Ito ang pinakabihirang ginagamit na uri ng integer sa Java. Ang pangunahing motibasyon para sa paggamit nito ay upang makatipid ng memorya.

Ipagpalagay na mayroon kang isang sitwasyon kung saan alam mo nang maaga na ikaw ay nagtatrabaho sa mga halagang hindi lalampas sa 30,000, at magkakaroon ng milyon-milyong mga halagang ito.

Halimbawa, sabihin nating nagsusulat ka ng isang application na nagpoproseso ng mga ultra-high definition na larawan na gumagamit ng 10-bits bawat kulay. At mayroon kang isang milyong pixel sa iyong larawan. Ito ay isang senaryo kung saan ang desisyon na gamitin into shortmahalaga.

longuri

Kinukuha ng ganitong uri ang pangalan nito long intat tinatawag ding long integer . Hindi tulad ng inturi, mayroon itong napakalaking hanay ng mga halaga: mula hanggang .-9*1018+9*1018

Bakit hindi ito ang pangunahing uri ng integer?

Dahil lumitaw ang Java noong kalagitnaan ng 90s, noong karamihan sa mga computer ay 32-bit. Nangangahulugan iyon na ang lahat ng mga processor ay na-optimize para sa pagtatrabaho sa mga numero na binubuo ng 32 bits. Ang mga processor ay maaaring gumana sa 64-bit na mga integer, ngunit ang mga operasyon sa kanila ay mas mabagal.

Bilang resulta, makatuwirang nagpasya ang mga programmer na gawin intang karaniwang uri ng integer, at gamitin longlamang ang uri kapag talagang kinakailangan.

byteuri

Ito ang pinakamaliit na uri ng integer sa Java, ngunit malayo sa hindi gaanong ginagamit. Ang pangalan nito, byte, ay ang salita din para sa pinakamaliit na addressable block ng memorya sa Java.

Walang ganoong karaming wastong mga halaga para sa byteuri: mula -128hanggang +127. Ngunit hindi iyon ang lakas nito. Ang byteuri ay kadalasang ginagamit kapag kailangan mong mag-imbak ng malaking data ng blob sa memorya. Ang isang array ng bytes ay perpekto para sa layuning ito.

Ipagpalagay na kailangan mong kopyahin ang isang file sa isang lugar.

Hindi mo kailangang iproseso ang mga nilalaman ng file: gusto mo lang lumikha ng isang lugar ng memorya (buffer), kopyahin ang mga nilalaman ng file dito, at pagkatapos ay isulat ang data mula sa buffer patungo sa isa pang file. Isang bytearray ang kailangan mo para dito.

Tandaan na ang isang array variable ay nag-iimbak lamang ng isang reference sa isang lugar ng memorya. Kapag ang variable ay naipasa sa ilang pamamaraan, tanging ang memory address lamang ang naipapasa. Ang bloke ng memorya mismo ay hindi kinopya.

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. Mga totoong uri

Kasama sa mga primitive na uri ang dalawang uri para sa mga tunay na numero. Bagama't hindi ganap na tumpak na gamitin ang terminong iyon. Kapag pinangangasiwaan ng mga computer ang mga totoong numero, tinatawag namin silang mga floating-point na numero . Ang pangalan ay nagmula sa isang pamantayan para sa kumakatawan sa mga numero, kung saan ang integer at fractional na bahagi ng isang numero ay pinaghihiwalay ng isang tuldok (isang punto, hindi isang kuwit).

Ang Java ay may dalawang floating-point primitive na uri: doubleat float.

Tulad ng sinabi namin kanina, ang mga uri na ito ay may napakaspesipikong panloob na kaayusan: sa katunayan, sa loob ng bawat variable ng mga uri na ito ay hindi isang numero, ngunit dalawa:

Halimbawa, ang floating-point number 987654.321ay maaaring katawanin bilang . Pagkatapos sa memorya ito ay kinakatawan bilang dalawang numero (ang mantissa , ibig sabihin, ang makabuluhang bahagi ng numero) at ( exponent , ibig sabihin, isang kapangyarihan ng sampu)0.987654321*1069876543216

floaturi

Ang pangalan ng floaturi ay nagmula sa float ing-point number . Ang laki ng ganitong uri ay medyo maliit — 4 bytes lamang (32 bits) — ngunit maaari itong mag-imbak ng mga halaga mula hanggang . 24 bits ay inilalaan para sa kumakatawan sa mantissa, at 8 bits para sa exponent. Ang ganitong uri ay may kakayahang mag-imbak lamang ng 8 makabuluhang digit.-3.4*10383.4*1038

Ginagawang posible ng diskarteng ito na mag-imbak ng mas malalaking numero kaysa sa isang int, habang ginagamit ang parehong 4 na byte. Ngunit para magawa ito, isinasakripisyo namin ang katumpakan. Dahil ang bahagi ng memorya ay nag-iimbak ng mantissa, ang mga variable na ito ay nag-iimbak lamang ng 6-7 decimal na lugar habang ang iba ay itinatapon.

Halimbawa:

float a = (float) 123.456789;

float a = (float) 12345.9999;

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

Tulad ng nakikita mo, ang pangunahing disbentaha ng ganitong uri ay ang napakaliit na bilang ng mga makabuluhang digit, at ang pagkawala ng katumpakan sa sandaling ang ikawalong digit. Iyon ang dahilan kung bakit ang floaturi ay hindi masyadong sikat sa mga Java programmer.

doubleuri

Ang doubleuri ay ang karaniwang uri ng floating-point. Ang pangalan ay nagmula sa double precision floating-point number . Ang lahat ng tunay na literal ay doubles bilang default.

Ang ganitong uri ay tumatagal ng hanggang 8 byte ng memory (64 bits) at maaaring mag-imbak ng mga halaga mula hanggang . Ang isang mahalagang bagay na dapat malaman ay ang 53 bits ay inilalaan para sa mantissa, habang ang natitirang 11 ay para sa exponent.-1.7*103081.7*10308

Nagbibigay-daan ito sa 15-17 makabuluhang digit na maiimbak.

Halimbawa:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

Ang katumpakan na ito, lalo na kung ihahambing sa floaturi, ay mapagpasyahan: 99% ng lahat ng mga operasyon na may totoong mga numero ay ginagawa gamit ang doubleuri.

11ang mga bit ay inilalaan para sa exponent, na nangangahulugang maaari kang mag-imbak ng mga kapangyarihan ng sampu mula -323hanggang +308(iyon ay isang kapangyarihan ng dalawa mula -1024hanggang +1023). Ang doubleuri ay madaling mag-imbak ng isang numero na may daan-daang mga zero pagkatapos ng decimal point:

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

4. Infinity

Ang mga floating-point na numero ay may isa pang kawili-wiling tampok: maaari silang mag-imbak ng isang espesyal na halaga na nagsasaad ng infinity . At maaari kang kumatawan sa positibong infinity at negatibong infinity .

Mga halimbawa:

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

Kung ang infinity ay i-multiply sa isang numero, makakakuha ka ng infinity. Kung magdagdag ka ng numero sa infinity, makakakuha ka ng infinity. Iyan ay sobrang maginhawa.

Hindi isang numero ( NaN)

Ang anumang mga operasyong kinasasangkutan ng infinity ay nagbubunga ng infinity. Well, karamihan pero hindi lahat.

Ang mga floating-point na numero ay maaaring mag-imbak ng isa pang espesyal na halaga: NaN. Ito ay maikli para sa N ot a N umber (hindi isang numero).

Sa matematika, kung hahatiin mo ang infinity sa infinity, hindi matukoy ang resulta.

Ngunit, sa Java, kung hahatiin mo ang infinity sa infinity, ang resulta ay NaN.

Mga halimbawa:

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

Anumang operasyon na may NaNmga magbubunga NaN.

5. charuri

Sa mga primitive na uri ng Javachar , ang isa ay nararapat ng ilang espesyal na atensyon: ang uri. Ang pangalan nito ay nagmula sa salitang char acter , at ang uri mismo ay ginagamit upang mag-imbak ng mga character.

Ang mga character ay kung saan ang mga string ay ginawa, tama? Ang mga string ay isang hanay ng mga character.

Ngunit ang mas kawili-wiling ay ang katotohanan na ang charuri ay isa ring uri ng numero ! Ito ay isang dual purpose type, wika nga.

Ang katotohanan ay ang charuri ay hindi aktwal na mga character. Sa halip, nag-iimbak ito ng mga character code mula sa Unicode encoding. Ang bawat karakter ay tumutugma sa isang numero: ang numerong code ng karakter.

Ang bawat charvariable ay sumasakop ng dalawang byte sa memorya (kapareho ng shorturi). Ngunit hindi tulad ng shorturi, ang charuri ng integer ay hindi naka-sign at maaaring mag-imbak ng mga halaga mula 0hanggang 65,535.

Ang charuri ay isang uri ng hybrid. Ang mga halaga nito ay maaaring bigyang-kahulugan bilang mga numero (hal., maaari silang idagdag at i-multiply) at bilang mga character. Ginawa ito dahil kahit na ang mga character ay mga visual na representasyon, sa isang computer ay higit sa lahat ang mga ito ay mga numero lamang. At mas maginhawang makipagtulungan sa kanila bilang mga numero.

Unicode

Ang Unicode ay isang espesyal na talahanayan (encoding) na naglalaman ng lahat ng mga character sa mundo. At ang bawat karakter ay may sariling numero. Ito ay mukhang humigit-kumulang na ganito:

Mayroong iba't ibang mga paraan upang magtalaga ng isang halaga sa isang charvariable.

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

Kadalasan, ipinapahiwatig lamang ng mga tao ang karakter sa mga panipi (tulad ng sa unang hilera ng talahanayan). Iyon ay sinabi, ang huling paraan ay popular din. Ang bentahe nito ay maaari itong magamit sa mga string.

At gaya ng sinabi namin, ang charuri ay isa ring uri ng integer, kaya maaari kang sumulat ng ganito:

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

Nagtatrabaho sa chars

Ang bawat isa charay una sa lahat isang numero (character code), at pagkatapos ay isang character. Kung alam mo ang isang character code, maaari mong palaging makuha ang character sa iyong programa. Halimbawa:

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

Ѩ

Mga karaniwang code

Narito ang mga pinakakilalang character code:

6. booleanuri

At ang huling primitive na uri ay boolean.

Tulad ng alam mo na, maaari lamang itong tumagal ng dalawang halaga: trueat false.

At kasama niyan, alam mo na ang lahat ng dapat malaman tungkol sa ganitong uri.