Forskel mellem int og lang
Indhold
Datatyperne int og lang hører til de to heltalsdatatyper, der er beskrevet i Java. I Java signeres typerne int og lang, + ve og -ve værdier. Java understøtter ikke usignerede int og lange typer. Den grundlæggende forskel mellem en int og lang datatype er bredden på hver type. Datatype int har bredden på 32-bit for variablen int type. På den anden side har datatypen lang bredden 64-bit for variablen lang type. Sammenligningstabellen nedenfor viser nogle andre forskelle mellem int og lang.
- Sammenligningstabel
- Definition
- Vigtige forskelle
- Konklusion
Sammenligningstabel
| Grundlag for sammenligning | int | lang |
|---|---|---|
| Grundlæggende | Datatypen int er på 32-bit. | Datatypen lang er på 64 bit. |
| bytes | Hvis der tælles i byte, er int 4 byte. | Hvis der tælles i byte, er lang 8 byte. |
| Rækkevidde | I Java er intervallet af type int –2,147.483.648 til 2.147.483.647. | I Java er området lang type –9.223.372.036.854.775.808 til 9.223.372.036.854.775.807. |
| Søgeord | Nøgleord, der bruges til at erklære en variabel af int-typen, er "int". | Nøgleord, der bruges til at erklære en variabel af lang type, er "lang". |
| Hukommelse | Hukommelse, der kræves for at gemme en int-variabel, er mindre sammenlignet med lang. | Hukommelse, der kræves for at gemme en lang variabel, er større sammenlignet med int. |
Definition af int-type
En datatype int er en mest almindeligt anvendt datatype, der indeholder en heltalværdi i den. En værdi, som en int-variabel kan indeholde, er ikke for kort og ikke for lang. Generelt bruges værdien af en int-variabel som en løkkevariabel, der styrer loopen, eller den bruges som en indeksvariabel for en matrix. Datatype byte og korte har kortere rækkevidde sammenlignet med datatype int, men de kan ikke erstatte int, selvom værdien af en int-variabel er af kortere rækkevidde. Årsagen bag dette er, at når vi bruger datatype byte og kort i et udtryk, så mens vi vurderer det udtryk, datatype byte og korte fremmes til int af kompilatoren. Så fra dette kan det siges, at det er bedre at bruge int, uanset hvor et heltal er nødvendigt.
Lad os se på brugen af int-datatype.
byte a = 70; byte b = 80; int c = a * b; // ingen fejl. byte d = a + 10; // Compile time error.
Som du kan se i ovenstående kode de to, byte-variabler a og b, der indeholder værdien 70 og 80, som er gyldig byte-varieret værdi. Men mellemresultatet af a * b; overskrider grænsen for byten. Derfor fremmer compileren automatisk byte-, kort- og char-variablerne til at skrive int, hvis de bruges i et udtryk. Nu kan du se, at resultatet af a * b er tildelt en int-variabel, der ikke forårsager nogen fejl og kompileres glat, fordi variablerne a og b fremmes til typen int og tildeling af type int til typen int ikke ' t forårsager fejlen.
I den sidste kodelinje kan du se et udtryk, hvor værdien 10 føjes til en bytevariabel 'a', hvis resultat stadig ikke overskred grænsen for byte. Men tildelingen af mellemresultatet af udtrykket "a + 10" til bytevariablen 'd' forårsager en kompilering af tidsfejl, fordi mens ekspressionsevalueringsbytevariablen 'a' fremmes til typen int. Og tildeling af type int til type byte er ikke tilladt. Derfor forårsager det en kompileringstidsfejl.
Definition af lang type
Datatypen lang har den største rækkevidde og bredde sammenlignet med byte-, korte- og int-typer. I Java er typen lang 64-bit signeret heltalstype. Type lang bruges, hvor type int ikke er så stor for at have den ønskede værdi. Omfanget af lang er –9.223.372.036.854.775.808 til 9.223.372.036.854.775.807, hvilket er ret stort, for at holde de større værdier som store heltal. Vi kan forstå typen lang med et eksempel nedenfor.
klasse vægt {offentligt statisk tomrum main (String args) {int item; int wt_per_item; lange gram; lang boks; vare = 10000000; // angiv antal poster wt_per_item = 10000; // angiv vægt på en vare i kilo gram = wt_item * 1000; // konverter vægt til gram Boks = vare * gram; // beregne kassens vægt i gram System.out.ln ("Antal vare" + vare); System.out.ln ("Vægt pr. Vare" + wt_per_item + "kilo"); System.out.ln ("Kassens vægt i gram" + Kasse + "kilo"); }} Antal vare 10000000 Vægt pr. Vare 10000 kilo Vægt af kasse i gram 100000000000000 kg
Se output i ovenstående kode; resultatet beregnes efter vægten af hele kassen, der indeholder kasse, der indeholder 10000000 genstande, hvoraf hver vare vejer 10000 kg. Den beregnede værdi for boksenes vægt i gram kan ikke holdes af en int-variabel. Derfor bliver det undertiden nødvendigt at bruge lang type, når store værdier skal beregnes eller holdes.
- Den grundlæggende forskel mellem typen int og lang er af deres bredde, hvor int er 32 bit, og lang er 64 bit.
- Typerne int og lang, når de tælles i byte i stedet for bit, er typen int 4 bytes, og typen lang er kun to gange, hvis typen int dvs. 8 byte.
- I Java er intervallet af type int fra –2,147,483,648 til 2,147,483,647, mens området for type lang er fra –9,223,372,036,854,775,808 til 9,223,372,036,854,775,807, hvilket er meget større end type int.
- Det nøgleord, der bruges til at erklære en variabel af typen int, er "int". På den anden side er nøgleordet, der bruges til at erklære variablen af typen lang, "lang".
- Generelt er den hukommelse, der kræves for at have værdien af type int, mindre sammenlignet med lang.
Konklusion:
Når du skriver kode, hvis der er behov for mellemværdi, kan du bruge typen int, men når output produceret af et hvilket som helst udtryk vil være større, eller de større værdier bruges til beregning, skal den lange type variabel bruges til at holde værdierne.
