Pagkakaiba sa pagitan ng int at mahaba
Nilalaman
Ang mga uri ng data int at mahaba ay kabilang sa dalawang uri ng data ng integer na inilarawan sa Java. Sa Java, ang mga uri ng int at mahaba ay naka-sign, + mga halaga ng ve at -ve. Hindi suportado ng Java ang hindi naka -ignign na int at mahabang uri. Ang pangunahing pagkakaiba sa pagitan ng isang int at mahabang uri ng data ay ang lapad ng bawat uri. Ang datatype int ay may lapad ng 32-bit para sa variable ng int type. Sa kabilang banda, ang uri ng data ng haba ay may lapad na 64-bit para sa variable ng mahabang uri. Ang tsart ng paghahambing sa ibaba ay nagpapakita ng ilang iba pang pagkakaiba sa pagitan ng int at mahaba.
- Tsart ng paghahambing
- Kahulugan
- Pangunahing Pagkakaiba
- Konklusyon
Tsart ng paghahambing
| Batayan para sa Paghahambing | int | mahaba |
|---|---|---|
| Pangunahing | Ang datatype int ay 32-bit. | Ang haba ng uri ng data ay 64-bit. |
| Mga byte | Kung binibilang sa mga byte, ang int ay 4 na bait. | Kung mabibilang sa mga byte, mahaba ang 8 bait. |
| Saklaw | Sa Java ang hanay ng uri int ay –2,147,483,648 hanggang 2,147,483,647. | Sa Java ang hanay ng uri ng haba ay -9,223,372,036,854,775,808 hanggang 9,223,372,036,854,775,807. |
| Keyword | Ang keyword na ginamit upang magpahayag ng isang variable ng uri ng int ay "int". | Ang keyword na ginamit upang magpahayag ng isang variable ng mahabang uri ay "mahaba". |
| Memorya | Ang memorya na kinakailangan upang mag-imbak ng isang variable ay mas mababa kumpara sa mahaba. | Ang memorya na kinakailangan upang mag-imbak ng isang mahabang variable ay mas malaki kaysa sa ihahambing sa int. |
Kahulugan ng uri ng int
Ang isang uri ng data int ay isang pinaka-karaniwang ginagamit na uri ng data na may hawak na halaga ng integer sa loob nito. Ang isang halaga na maaaring hawakan ng isang variable ay hindi masyadong maikli at hindi masyadong mahaba. Kadalasan, ang halaga ng isang variable ay ginagamit bilang isang variable variable na kinokontrol ang loop, o ginagamit ito bilang isang variable ng index ng isang hanay. Ang uri ng data ngte at maikli ay may mas maiikling saklaw kung ihahambing sa uri ng data int, ngunit hindi nila mapapalitan ang int, kahit na ang halaga ng isang variable ay mas maiikling saklaw. Ang dahilan sa likod nito ay kapag gumagamit kami ng data type byte at maikli sa isang expression pagkatapos habang sinusuri ang expression na ang data type byte at maikli ay nai-promote sa int ng tagatala. Kaya, mula rito, masasabi na mas mahusay na gamitin ang int saanman kailangan ang isang integer.
Tingnan natin ang paggamit ng int datatype.
byte a = 70; byte b = 80; int c = a * b; // walang error. byte d = a + 10; // Compile error sa oras.
Tulad ng maaari mong obserbahan sa itaas na code ang dalawa, mga variable na byte at b na naglalaman ng halaga ng 70 at 80, na kung saan ay may bisa na halaga ng baitang. Ngunit, ang intermediate na resulta ng isang * b; lumampas sa limitasyon ng byte. Samakatuwid, ang tagatala ay awtomatikong nagtataguyod ng mga variable na byte, maikli at char upang mag-type ng int, kung ginagamit ito sa isang expression. Ngayon, makikita mo na ang resulta ng isang * b ay itinalaga sa isang variable na hindi nagiging sanhi ng anumang pagkakamali at nag-iipon ng maayos dahil ang mga variable at a b ay nai-promote sa uri int at pagtatalaga ng uri int sa uri int doesn ' t sanhi ng pagkakamali.
Sa huling linya ng code, maaari kang makakita ng isang expression, kung saan ang halaga ng 10 ay idinagdag sa isang variable na byte 'a' ang resulta ay hindi pa rin lumampas sa limitasyon ng byte. Ngunit, ang pagtatalaga ng intermediate na resulta ng expression na "a + 10" sa byte variable na 'd', ay nagiging sanhi ng isang error na compile time dahil habang ang expression evaluation byte variable 'a' ay nai-promote sa uri int. At ang pagtatalaga ng type int to type byte ay hindi pinapayagan. Samakatuwid, nagdudulot ito ng isang pagkalkula ng error sa oras.
Kahulugan ng mahabang uri
Ang haba ng uri ng data ay may pinakamalaking saklaw at lapad kung ihahambing sa byte, maikli, at mga uri ng int. Sa Java, ang uri ng haba ay 64-bit na naka-sign na uri ng integer. Ang uri ng haba ay ginagamit kung saan ang uri int ay hindi ganoon kalawak upang hawakan ang nais na halaga. Ang saklaw ng haba ay –9,223,372,036,854,775,808 hanggang 9,223,372,036,854,775,807 na medyo malaki, upang hawakan ang mas malaking halaga tulad ng malaking buong bilang. Maaari naming maunawaan ang uri ng haba na may isang halimbawa sa ibaba.
bigat ng klase {pampublikong static na walang bisa (String args) {int item; int wt_per_item; mahabang gramo; mahabang Kahon; item = 10000000; // tukuyin ang mga item ng numero wt_per_item = 10000; // tukuyin ang bigat ng isang item sa kilong gramo = wt_item * 1000; // convert ang timbang sa gramo Box = item * gramo; // compute bigat ng kahon sa gramo System.out.ln ("Bilang ng item" + item); System.out.ln ("Timbang sa bawat item" + wt_per_item + "kilos"); System.out.ln ("Timbang ng kahon sa gramo" + Box + "kilos"); }} Bilang ng item 10000000 Timbang bawat item 10000 kilo Timbang ng kahon sa gramo 100000000000000 kilo
Sundin ang output sa itaas na code; ang resulta na naipon para sa bigat ng buong kahon na naglalaman ng kahon na naglalaman ng 10000000 na mga item kung saan ang bawat timbang ng item na 10000 kilo. Ang nakalkula na halaga para sa bigat ng kahon sa gramo, ay hindi maaaring hawakan ng isang variable. Samakatuwid, kung minsan kinakailangan na gumamit ng mahabang uri kapag ang mga malalaking halaga ay dapat makalkula o hawakan.
- Ang pangunahing pagkakaiba sa pagitan ng uri ng int at haba ay ang kanilang lapad kung saan ang int ay 32 bit, at mahaba ay 64 bits.
- Ang mga uri int at mahaba kapag binibilang sa mga byte sa halip na bits ang uri ng int ay 4 na bait at ang haba ng haba ay dalawang beses lamang kung type int i.e. 8 byte.
- Sa Java, ang saklaw ng uri int ay mula sa –2,147,483,648 hanggang 2,147,483,647 samantalang, ang saklaw ng uri ng haba ay mula sa –9,223,372,036,854,775,808 hanggang 9,223,372,036,854,775,807 na higit na malaki kaysa sa type int.
- Ang keyword na ginamit sa pagpapahayag ng isang variable ng uri int ay "int". Sa kabilang banda, ang keyword na ginamit upang maipahayag ang variable ng uri ng haba ay "mahaba".
- Karaniwan, ang memorya na kinakailangan upang hawakan ang halaga ng uri int ay mas mababa kumpara sa mahaba.
Konklusyon:
Habang sinusulat ang code kung may pangangailangan para sa halaga ng medium range pagkatapos ay maaari mong gamitin ang type int ngunit kapag ang output na ginawa ng anumang expression ay magiging malaki, o ang mas malaking halaga ay ginagamit para sa pagkalkula pagkatapos ang mahabang uri ng variable ay dapat gamitin upang hawakan ang mga halaga.
