Diferència entre int i llarg
Content
Els tipus de dades int i long es troben entre els dos tipus de dades sencers descrits a Java. A Java, els tipus int i long estan signats, + i i -ve valors. Java no admet tipus int llarg i sense signar. La diferència fonamental entre un tipus de dades int i llarg és l'amplada de cada tipus. El tipus de dades int té l'amplada de 32 bits per a la variable de tipus int. D'altra banda, el tipus de dades llarg té l'amplada de 64 bits per a la variable de tipus llarg. El gràfic de comparació següent mostra algunes altres diferències entre int i llarg.
- Gràfic de comparació
- Definició
- Diferències claus
- Conclusió
Gràfic de comparació
| Bases per a la comparació | int | llarg |
|---|---|---|
| Bàsic | El tipus de dades int és de 32 bits. | El tipus de dades llarg és de 64 bits. |
| Bytes | Si es compta en bytes, int és de 4 bytes. | Si es compta en bytes, el llarg és de 8 bytes. |
| Abast | A Java, l'interval de tipus int és de -2.147.483.648 a 2.147.483.647. | A Java l’interval de tipus llarg és –9.223.372.036.854.775.808 a 9.223.372.036.854.775.807. |
| Paraula clau | La paraula clau utilitzada per declarar una variable de tipus int és "int". | La paraula clau utilitzada per declarar una variable de tipus llarg és "llarga". |
| Memòria | La memòria necessària per emmagatzemar una variable int és menor en comparació amb el llarg. | La memòria necessària per emmagatzemar una variable llarga és més gran en comparació amb la int. |
Definició de tipus int
Un tipus de dades int és un tipus de dades més utilitzat que conté un valor enter. Un valor que pot tenir una variable int no és massa curt ni massa llarg. Generalment, el valor d'una variable int s'utilitza com a variable de bucle que controla el bucle, o s'utilitza com a variable índex d'una matriu. El byte de tipus de dades i el de curt tenen un abast més curt en comparació amb el tipus de dades int, però no poden substituir int, encara que el valor d’una variable int sigui d’interval més curt. La raó d'aquesta raó és que quan utilitzem el tipus de dades byte i short en una expressió, aleshores, mentre avaluem aquesta expressió, el compilador de tipus byte i short de dades es promouen a l'int per el compilador. Així doncs, a partir d’això, es pot dir que és millor utilitzar int allà on calgui un nombre enter.
Vegem l'ús de tipus de dades d'int.
byte a = 70; byte b = 80; int c = a * b; // cap error. byte d = a + 10; // Error de temps de compilació.
Com podeu observar en el codi anterior les dues, les variables a i b de bytes que contenen els valors 70 i 80, que és vàlid de rang de byte. Però, el resultat intermedi de a * b; supera el límit del byte. Per tant, el compilador promou automàticament les variables de byte, short i char per escriure int, si s’utilitzen en una expressió. Ara, podeu veure que el resultat de a * b s'assigna a una variable int que no causa cap error i es compila sense problemes perquè les variables a i b es promouen al tipus int i l'assignació del tipus int al tipus int no ' No causar l’error.
A l’última línia de codi, podeu veure una expressió, on el valor 10 s’afegeix a una variable de bytes “a” el seu resultat encara no superava el límit del byte. Però, l'assignació del resultat intermedi de l'expressió "a + 10" a la variable d'octets "d", provoca un error en el temps de compilació, ja que mentre es promou la variable "a" del byte d'avaluació d'expressió al tipus int. I no es permet l’assignació de tipus int al byte de tipus. Per tant, provoca un error en el temps de compilació.
Definició de tipus llarg
El tipus de dades llarg té l’amplitud i l’amplada més gran en comparació dels tipus byte, short i int. A Java, el tipus llarg és de tipus enter signat de 64 bits. El tipus llarg s'utilitza quan el tipus int no és tan gran per mantenir el valor desitjat. El rang de llarg és de –9.223.372.036.854.775.808 a 9.223.372.036.854.775.807, que és bastant gran, per mantenir els valors més grans com els nombres sencers. Podem entendre el tipus llarg amb un exemple a continuació.
class weight {public static void main (String args) {int item; int wt_per_item; grams llargs; llarga caixa; article = 10000000; // especificar el número d'elements wt_per_item = 10000; // especifiqueu el pes d’un article en quilos de gramos = wt_item * 1000; // convertir pes a gram Quadre = ítem * grams; // calcula el pes de la caixa en grams System.out.ln ("Nombre d'article" + ítem); System.out.ln ("Pes per article" + wt_per_item + "quilos"); System.out.ln ("Pes de la caixa en gram" + Caixa + "quilos"); }} Nombre d'article 10000000 Pes per article 10000 quilos Pes de caixa en gram 100000000000000 quilos
Observeu la sortida del codi anterior; el resultat calculat per al pes de la caixa sencera que conté 10000000 ítems dels quals per article pesa 10000 quilos. El valor calculat per al pes de la caixa en grams no es pot retenir per una variable int. Per tant, de vegades és necessari utilitzar tipus llarg quan es calculen o mantenen els valors grans.
- La diferència bàsica entre el tipus int i el llarg és de la seva amplada, on int és de 32 bits, i el llarg és de 64 bits.
- El tipus int i llarg quan es comptabilitzen en bytes en lloc de bits, el tipus int és de 4 bytes i el tipus llarg és només dos cops si el tipus int és a dir, 8 bytes.
- A Java, l’interval de tipus int és de –2,147.483.648 a 2.147.483.647 mentre que, l’interval de tipus llarg és de –9.223.372.036.854.775.808 a 9.223.372.036.854.775.807, molt més gran que el tipus int.
- La paraula clau que s'utilitza per declarar una variable del tipus int és "int". D'altra banda, la paraula clau utilitzada per declarar la variable de tipus llarg és "llarga".
- Generalment, la memòria necessària per mantenir el valor del tipus int és menor en comparació amb el llarg.
Conclusió:
Mentre escriviu codi si hi ha necessitat de valor de rang mitjà, podeu utilitzar el tipus int, però quan la sortida produïda per qualsevol expressió serà més gran o els valors més grans s’estan utilitzant per a càlcul, aleshores s’ha de fer servir la variable de tipus llarg. els valors.
