Skillnad mellan int och lång
Innehåll
Datatyperna int och lång är bland de två heltaldatatyper som beskrivs i Java. I Java är typen int och long signerade, + ve och -ve-värden. Java stöder inte osignerade int och långa typer. Den grundläggande skillnaden mellan en int och lång datatyp är bredden på varje typ. Datatypen int har bredden 32-bitars för variabeln int-typ. Å andra sidan har datatypen lång bredden 64-bitars för variabeln lång typ. Jämförelsetabellen nedan visar några andra skillnader mellan int och lång.
- Jämförelsediagram
- Definition
- Viktiga skillnader
- Slutsats
Jämförelsediagram
| Grund för jämförelse | int | lång |
|---|---|---|
| Grundläggande | Datatypen är 32-bitar. | Datatypen lång är 64-bitar. |
| bytes | Om det räknas i byte är intet 4 byte. | Om det räknas i byte är lång 8 byte. |
| Räckvidd | I Java är intervallet av typ int –2,147,483,648 till 2,147,483,647. | I Java är intervallet av typen lång –9,223,372,036,854,775,808 till 9,223,372,036,854,775,807. |
| Nyckelord | Nyckelord som används för att förklara en variabel av int-typen är "int". | Nyckelord som används för att förklara en variabel av lång typ är "lång". |
| Minne | Det minne som krävs för att lagra en int-variabel är mindre jämfört med långt. | Det minne som krävs för att lagra en lång variabel är större jämfört med int. |
Definition av int-typ
En datatyp int är en vanligaste datatyp som innehåller ett heltal i det. Ett värde som en int-variabel kan innehålla är inte för kort och inte för långt. I allmänhet används värdet på en int-variabel som en slingvariabel som styr slingan, eller den används som en indexvariabel för en matris. Datatypens byte och korta har kortare intervall jämfört med datatypen int, men de kan inte ersätta int, även om värdet på en int-variabel är av kortare intervall. Anledningen bakom detta är att när vi använder datatypbyte och kort i ett uttryck, då vi utvärderar det uttrycket, datatypsbyte och kort befordras till int av kompilatorn. Så härifrån kan man säga att det är bättre att använda int därhelst ett heltal behövs.
Låt oss titta på användningen av int-datatyp.
byte a = 70; byte b = 80; int c = a * b; //inget fel. byte d = a + 10; // Kompilera tidsfel.
Som du kan observera i ovanstående kod de två, bytevariablerna a och b som innehåller värdet 70 och 80, vilket är giltigt byte-intervallvärde. Men mellanresultatet av a * b; överskrider gränsen för byten. Därför marknadsför kompilatorn automatiskt byte-, kort- och char-variablerna för att skriva int om de används i ett uttryck. Nu kan du se att resultatet av a * b tilldelas en int-variabel som inte orsakar något fel och kompilerar smidigt eftersom variablerna a och b befordras till typen int och tilldelning av typ int till typen int inte ' t orsakar felet.
I den sista kodraden kan du se ett uttryck, där värdet 10 läggs till i en bytevariabel 'a', dess resultat överskred fortfarande inte gränsen för byten. Men tilldelningen av mellanresultatet av uttrycket "a + 10" till bytevariabeln "d" orsakar ett kompileringstidsfel eftersom medan uttryck utvärderingsbytevariabel "a" befordras till typen int. Och tilldelning av typ int för att skriva byte är inte tillåtet. Därför orsakar det ett kompileringstidsfel.
Definition av lång typ
Datatypen lång har det största intervallet och bredden jämfört med byte-, kort- och int-typer. I Java är typen lång 64-bitars signerad heltalstyp. Typen lång används där typen int inte är så stor för att hålla önskat värde. Långområdet är –9,223,372,036,854,775,808 till 9,223,372,036,854,775,807 vilket är ganska stort för att hålla de större värdena som stora heltal. Vi kan förstå typen långt med ett exempel nedan.
klassvikt {public static void main (String args) {int artikel; int wt_per_item; långa gram; lång låda; artikel = 10000000; // specificera antal objekt wt_per_item = 10000; // ange vikten på en artikel i kilo gram = wt_item * 1000; // konvertera vikt till gram Box = artikel * gram; // beräkna lådans vikt i gram System.out.ln ("Antal objekt" + objekt); System.out.ln ("Vikt per artikel" + wt_per_item + "kilo"); System.out.ln ("Boxens vikt i gram" + Box + "kilo"); }} Antal objekt 10000000 Vikt per artikel 10000 kilo Lådans vikt i gram 100000000000000 kilo
Observera utgången i koden ovan; resultatet beräknas för vikten på hela lådan innehållande låda som innehåller 10000000 artiklar varav per artikel väger 10000 kilo. Det beräknade värdet för lådans vikt i gram kan inte hållas av en int-variabel. Därför blir det ibland nödvändigt att använda lång typ när stora värden ska beräknas eller hållas.
- Den grundläggande skillnaden mellan typen int och lång är av deras bredd där int är 32 bitar och lång är 64 bitar.
- Typerna int och långa när de räknas i byte istället för bitar är typen int 4 byte och typen lång är bara två gånger om typen int dvs. 8 byte.
- I Java är intervallet av typ int från –2,147,483,648 till 2,147,483,647, medan intervallet av typen lång är från –9,223,372,036,854,775,808 till 9,223,372,036,854,775,807, vilket är mycket större än typ int.
- Nyckelordet som används för att deklarera en variabel av typen int är "int". Å andra sidan är nyckelordet som används för att förklara variabeln av typen lång "långt".
- Generellt är minnet som krävs för att hålla värdet på typ int mindre jämfört med långt.
Slutsats:
När du skriver kod om det finns behov av medelvärde kan du använda typen int men när utdata som produceras av något uttryck blir större, eller de större värdena används för beräkning måste den långa typvariabeln användas för att hålla värdena.
