streamalism.org

1. Overzicht

De Java-programmeertaal heeft acht primitieve gegevenstypen.

In dit artikel zullen we ons herinneren wat primitieven zijn en ze bespreken.

2. Primitieve gegevenstypen

De acht primitieven die in Java zijn gedefinieerd, zijn int, byte, kort, lang, vlotter, dubbele, boolean, en char - die worden niet als objecten beschouwd en vertegenwoordigen ruwe waarden.

Ze worden direct op de stapel opgeslagen (bekijk dit artikel voor meer informatie over geheugenbeheer in Java).

Laten we eens kijken naar de opslaggrootte, standaardwaarden en voorbeelden van het gebruik van elk type.

Laten we beginnen met een korte referentie:

2.1. int

Het eerste primitieve gegevenstype dat we gaan behandelen is int. Ook bekend als een geheel getal, int type bevat een breed scala aan niet-fractionele getallen.

Specifiek, Java slaat het op met 32 ​​bits geheugen. Met andere woorden, het kan waarden vertegenwoordigen van -2.147.483.648 (-231) tot 2.147.483.647 (231-1).

In Java 8 is het mogelijk om een ​​geheel getal zonder teken tot 4.294.967.295 (232-1) op te slaan met behulp van nieuwe speciale hulpfuncties.

We kunnen eenvoudig een int simpelweg:

int x = 424_242; int y;

De standaardwaarde van een int gedeclareerd zonder toewijzing is 0.

Als de variabele is gedefinieerd in een methode, moeten we een waarde toewijzen voordat we deze kunnen gebruiken.

We kunnen alle standaard rekenkundige bewerkingen uitvoeren op ints. Houd daar rekening mee decimale waarden worden afgehakt bij het uitvoeren van deze op gehele getallen.

2.2. byte

byte is een primitief gegevenstype vergelijkbaar met int, behalve het neemt slechts 8 bits geheugen in beslag. Daarom noemen we het een byte. Omdat het geheugen zo klein is, byte kan alleen de waarden bevatten van -128 (-27) tot 127 (27 - 1).

We kunnen creëren byte:

byte b = 100; byte leeg;

De standaardwaarde van byte is ook 0.

2.3. kort

De volgende stop op onze lijst met primitieve gegevenstypen in Java is kort.

Als we geheugen willen besparen en byte te klein is, kunnen we het type halverwege tussen de twee gebruiken: kort.

Met 16 bits geheugen is het de helft van de grootte van int en twee keer zo groot als byte. Het bereik van mogelijke waarden is -32.768 (-215) tot 32.767 (215 - 1).

kort wordt als volgt verklaard:

korte s = 202_020; korte broek;

Ook vergelijkbaar met de andere typen, is de standaardwaarde 0. We kunnen er ook alle standaardberekeningen op gebruiken.

2.4. lang

Ons laatste primitieve gegevenstype met betrekking tot gehele getallen is lang.

lang is de grote broer van int. Het is opgeslagen in 64 bits geheugen dus het kan een aanzienlijk grotere reeks mogelijke waarden bevatten.

De mogelijke waarden van een long liggen tussen -9.223.372.036.854.775.808 (-263) en 9.223.372.036.854.775.807 (263 - 1).

We kunnen er eenvoudig een declareren:

lange l = 1_234_567_890; lang l;

Net als bij andere typen gehele getallen, is de standaardwaarde ook 0. We kunnen alle rekenkunde gebruiken op lang dat werkt verder int.

2.5. vlotter

We vertegenwoordigen eenvoudige fractionele getallen in Java met behulp van de vlotter type. Dit is een decimaal getal met één precisie. Wat betekent dat als we voorbij zes decimalen komen, dit aantal minder nauwkeurig en meer een schatting wordt.

In de meeste gevallen geven we niet om het precisieverlies. Maar als onze berekening absolute precisie vereist (d.w.z. financiële operaties, landen op de maan, enz.), Moeten we specifieke typen gebruiken die voor dit werk zijn ontworpen. Bekijk voor meer informatie de Java-klasse Big Decimal.

Dit type wordt net als in 32 bits geheugen opgeslagen int. Vanwege de drijvende komma is het bereik echter heel anders. Het kan zowel positieve als negatieve getallen vertegenwoordigen. De kleinste decimaal is 1,40239846 x 10-45 en de grootste waarde is 3,40282347 x 1038.

We verklaren vlotteris hetzelfde als elk ander type:

zweven f = 3.145f; zweven f;

En de standaardwaarde is 0,0 in plaats van 0. Merk ook op dat we de f aanduiding aan het einde van het letterlijke getal om een ​​float te definiëren. Anders genereert Java een fout omdat het standaardtype van een decimale waarde dubbele.

We kunnen ook alle standaard rekenkundige bewerkingen uitvoeren op vlotters. Het is echter belangrijk op te merken dat we drijvende-kommaberekeningen heel anders uitvoeren dan rekenen met gehele getallen.

2.6. dubbele

Vervolgens kijken we naar dubbele - de naam komt van het feit dat het een decimaal getal met dubbele precisie is.

Het is opgeslagen in 64 bits geheugen. Wat betekent dat het een veel groter bereik van mogelijke getallen vertegenwoordigt dan vlotter.

Hoewel het lijdt aan dezelfde precisiebeperking als vlotter doet. Het bereik is 4.9406564584124654 x 10-324 tot 1.7976931348623157 x 10308. Dat bereik kan ook positief of negatief zijn.

Verklaren dubbele is hetzelfde als andere numerieke typen:

dubbele d = 3,13457599923384753929348D; dubbele d;

De standaardwaarde is ook 0,0 zoals het is vlotter.Gelijkwaardig aan vlotter, we voegen de brief toe D om het letterlijke aan te duiden als een dubbelganger.

2.7. boolean

Het eenvoudigste primitieve gegevenstype is boolean. Het kan slechts twee waarden bevatten: waar of false. Het slaat zijn waarde op in een enkel bit.

Gemakshalve vult Java de waarde echter op en slaat deze op in een enkele byte.

Verklaren boolean soortgelijk:

boolean b = true; boolean b;

Het declareren zonder een waarde is standaard ingesteld op false. boolean is de hoeksteen van het beheersen van onze programmastroom. We kunnen er booleaanse operatoren op gebruiken (d.w.z. en, of, enz.).

2.8. char

Het laatste primitieve gegevenstype om naar te kijken is char.

Ook wel een personage genoemd, char is een 16-bits geheel getal dat een Unicode-gecodeerd teken vertegenwoordigt. Het bereik is van 0 tot 65.535. Wat in Unicode staat voor ‘\ U0000 ' naar ‘\ Uffff '.

Kijk voor een lijst met alle mogelijke Unicode-waarden op sites zoals Unicode Table.

Laten we nu een char:

char c = 'a'; char c = 65; char c;

Bij het definiëren van onze variabelen kunnen we elk letterteken gebruiken, en ze worden automatisch omgezet in hun Unicode-codering voor ons. De standaardwaarde van een teken is ‘/ U0000 '.

2.9. Overloop

De primitieve gegevenstypen hebben groottelimieten. Maar wat gebeurt er als we proberen een waarde op te slaan die groter is dan de maximale waarde?

We komen een situatie tegen die wordt gebeld overloop.

Wanneer een geheel getal overloopt, gaat het over naar de minimumwaarde en begint vanaf daar te tellen.

Drijvende-kommagetaloverloop door oneindigheid terug te geven. Als ze onderlopen, geven ze 0,0 terug.

Hier is een voorbeeld:

int i = Geheel getal.MAX_VALUE; int j = i + 1; // j zal overgaan naar -2_147_483_648 double d = Double.MAX_VALUE; dubbel o = d + 1; // o wordt Infinity

Onderstroom is hetzelfde probleem, behalve als we een waarde opslaan die kleiner is dan de minimumwaarde.

2.10. Autoboxing

Elk primitief gegevenstype heeft ook een volledige Java-klasse-implementatie die het kan omhullen. Bijvoorbeeld de Geheel getal klasse kan een int. Soms is het nodig om van het primitieve type naar de objectomhulling te converteren (bijvoorbeeld om ze te gebruiken met generieke termen).

Gelukkig kan Java deze conversie automatisch voor ons uitvoeren. We noemen dit proces Autoboxing. Hier is een voorbeeld:

Teken c = 'c'; Geheel getal i = 1;

3. Conclusie

In deze zelfstudie hebben we de acht primitieve gegevenstypen behandeld die in Java worden ondersteund.

Dit zijn de bouwstenen die door de meeste, van niet alle, Java-programma's worden gebruikt - dus het is de moeite waard om te begrijpen hoe ze werken.