Primitieve typen op Java

1. Lijst met primitieve typen

Java heeft 8 fundamentele primitieve typen. Ze worden primitief genoemd omdat de waarden van deze typen geen objecten zijn en rechtstreeks in variabelen worden opgeslagen.

Hier is een tabel met wat korte informatie over deze typen:

Lokale variabelen in een methode hebben geen standaardwaarde. Als u geen waarde toewijst aan dergelijke variabelen, worden ze als niet-geïnitialiseerd beschouwd en kunnen ze niet worden gebruikt.

Maar laten we terugkeren naar primitieve typen en ze eens nader bekijken.

2. Integer-typen

Java heeft 4 typen gehele getallen: byte, short, inten long. Ze verschillen in hun grootte en het bereik van waarden die ze kunnen opslaan.

inttype

De meest gebruikte is het inttype. De naam komt van het woord integer ( geheel getal). Alle letterlijke gehele getallen (hele getallen) in code zijn ints(als ze niet eindigen op een L, F, of D).

Variabelen van dit type kunnen waarden aannemen van -2,147,483,648tot +2,147,483,647.

Dat is veel en voldoende voor bijna elke gelegenheid. Bijna elke functie die een getal retourneert, retourneert een int.

Voorbeelden:

int n = "String".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.length;

shorttype

Het shorttype dankt zijn naam aan short int. Het wordt ook vaak een kort geheel getal genoemd . In tegenstelling tot het inttype is de lengte slechts twee bytes en is het bereik van mogelijke waarden van -32,768tot +32,767.

Dat betekent dat je het getal een miljoen er niet in kunt opslaan. Of zelfs 50.000. Dit is het meest zelden gebruikte integer-type in Java. De belangrijkste motivatie om het te gebruiken is om geheugen te besparen.

Stel dat je een situatie hebt waarin je van tevoren weet dat je gaat werken met waarden die nooit hoger zijn dan 30.000, en er zullen miljoenen van deze waarden zijn.

Stel dat u bijvoorbeeld een toepassing schrijft die afbeeldingen met ultrahoge definitie verwerkt die 10-bits per kleur gebruiken. En je hebt een miljoen pixels in je foto. Dit is een scenario waarbij de beslissing om te gebruiken intof shortertoe doet.

longtype

Dit type dankt zijn naam aan long inten wordt ook wel een lang geheel getal genoemd . In tegenstelling tot het inttype heeft het een fabelachtig enorm scala aan waarden: van tot .-9*1018+9*1018

Waarom is het niet het standaard integer type?

Omdat Java halverwege de jaren 90 verscheen, toen de meeste computers 32-bits waren. Dat betekent dat alle processors zijn geoptimaliseerd voor het werken met getallen bestaande uit 32 bits. Processors konden werken met 64-bits gehele getallen, maar de bewerkingen ermee waren langzamer.

Als gevolg hiervan besloten programmeurs redelijkerwijs om inthet standaard integer-type te maken en het longtype alleen te gebruiken wanneer het echt nodig is.

bytetype

Dit is het kleinste gehele type in Java, maar verre van het minst gebruikt. De naam, byte, is ook het woord voor het kleinste adresseerbare geheugenblok in Java.

Er zijn niet zoveel geldige waarden voor het bytetype: from -128to +127. Maar dat is niet zijn kracht. Het bytetype wordt meestal gebruikt wanneer u grote blobgegevens in het geheugen moet opslaan. Een reeks van bytes is hiervoor ideaal.

Stel dat u ergens een bestand moet kopiëren.

U hoeft de inhoud van het bestand niet te verwerken: u wilt gewoon een geheugengebied (buffer) maken, de inhoud van het bestand erin kopiëren en die gegevens vervolgens van de buffer naar een ander bestand schrijven. byteHiervoor heb je een array nodig.

Houd er rekening mee dat een matrixvariabele alleen een verwijzing naar een geheugengebied opslaat. Wanneer de variabele wordt doorgegeven aan een methode, wordt alleen het geheugenadres doorgegeven. Het geheugenblok zelf wordt niet gekopieerd.

byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
   int size = sourceFile.read(buffer); // Read data from a file into a buffer
   destFile.write(buffer, 0, size); // Write data from the buffer to a file

   // Stop copying if the buffer is not full
   if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();

3. Echte typen

De primitieve typen omvatten twee typen voor reële getallen. Hoewel het niet helemaal juist is om die term te gebruiken. Wanneer computers met reële getallen omgaan, noemen we ze getallen met drijvende komma . De naam komt van een standaard voor het weergeven van getallen, waarbij de gehele en gebroken delen van een getal worden gescheiden door een punt (een punt, geen komma).

Java heeft twee primitieve typen met drijvende komma: doubleen float.

Zoals we eerder zeiden, hebben deze typen een zeer specifieke interne rangschikking: in feite is binnen elke variabele van deze typen niet één getal, maar twee:

Het getal met drijvende komma kan bijvoorbeeld 987654.321worden weergegeven als . Dan wordt het in het geheugen weergegeven als twee getallen (de mantisse , dwz het significante deel van het getal) en ( exponent , dwz een macht van tien)0.987654321*1069876543216

floattype

De naam van het floattype komt van een getal met drijvende komma . De grootte van dit type is vrij klein - slechts 4 bytes (32 bits) - maar het kan waarden opslaan van tot . Er zijn 24 bits toegewezen voor het weergeven van de mantisse en 8 bits voor de exponent. Dit type kan slechts 8 significante cijfers opslaan.-3.4*10383.4*1038

Deze benadering maakt het mogelijk om veel grotere getallen op te slaan dan een int, terwijl dezelfde 4 bytes worden gebruikt. Maar om dat te doen, offeren we nauwkeurigheid op. Omdat een deel van het geheugen de mantisse opslaat, slaan deze variabelen slechts 6-7 decimalen op, terwijl de rest wordt weggegooid.

Voorbeeld:

float a = (float) 123.456789;

float a = (float) 12345.9999;

float a = (float) -123.456789E-2;

Zoals u kunt zien, is het belangrijkste nadeel van dit type het zeer kleine aantal significante cijfers en het verlies van precisie vanaf het achtste cijfer. Daarom floatis het type niet erg populair onder Java-programmeurs.

doubletype

Het doubletype is het standaard drijvende-kommatype. De naam komt van dubbele precisie floating-point number . Alle echte literals zijn doublestandaard s.

Dit type neemt 8 bytes geheugen in beslag (64 bits) en kan waarden opslaan van tot . Een belangrijk ding om te weten is dat 53 bits zijn toegewezen voor de mantisse, terwijl de resterende 11 voor de exponent zijn.-1.7*103081.7*10308

Hierdoor kunnen 15-17 significante cijfers worden opgeslagen.

Voorbeeld:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

Deze precisie, zeker in vergelijking met het floattype, is doorslaggevend: 99% van alle bewerkingen met reële getallen wordt uitgevoerd met behulp van het doubletype.

11bits worden toegewezen voor de exponent, wat betekent dat je machten van tien kunt opslaan van -323tot +308(dat is een macht van twee van -1024tot +1023). Het doubletype kan gemakkelijk een getal opslaan met honderden nullen achter de komma:

double a = 2E-300 * 3E+302

4. Oneindigheid

Drijvende-kommagetallen hebben nog een ander interessant kenmerk: ze kunnen een speciale waarde opslaan die oneindigheid aangeeft . En je kunt positieve oneindigheid en negatieve oneindigheid vertegenwoordigen .

Voorbeelden:

System.out.println( 100.0 / 0.0 );

Infinity

System.out.println( -100.0 / 0.0 );

-Infinity

double a = 1d / 0d;
double b = a * 10;
double c = b - 100;

a == Infinity
b == Infinity
c == Infinity

Als oneindig wordt vermenigvuldigd met een getal, krijg je oneindig. Als je een getal optelt bij oneindig, krijg je oneindig. Dat is superhandig.

Geen nummer ( NaN)

Elke bewerking waarbij oneindigheid betrokken is, levert oneindig op. Nou ja, de meeste maar niet alle.

Drijvende-kommagetallen kunnen nog een speciale waarde opslaan: NaN. Het is een afkorting van Not a Number ( geen nummer ) .

Als je in de wiskunde oneindig door oneindig deelt, is het resultaat ongedefinieerd.

Maar als je in Java oneindig door oneindig deelt, is het resultaat NaN.

Voorbeelden:

System.out.println(0.0 / 0.0);

NaN

double infinity = 1d / 0d;
System.out.println(infinity / infinity);

NaN

double a = 0.0 / 0.0;
double b = a * 10;
double c = b - 100;
double d = a + infinity;

a == NaN
b == NaN
c == NaN
d == NaN

Elke operatie met NaNopbrengsten NaN.

5. chartypen

Van de primitieve typen van Java verdient er één speciale aandacht: het chartype. De naam komt van het woord karakter en het type zelf wordt gebruikt om karakters op te slaan.

Tekens zijn waar snaren van gemaakt zijn, toch? Strings zijn een reeks tekens.

Maar nog interessanter is het feit dat het chartype ook een numeriek type is ! Het is een soort met twee doelen, om zo te zeggen.

De realiteit is dat het chartype eigenlijk geen karakters heeft. In plaats daarvan slaat het tekencodes op van de Unicode-codering. Elk teken komt overeen met een nummer: de numerieke code van het teken.

Elke charvariabele neemt twee bytes in het geheugen in beslag (hetzelfde als het shorttype). Maar in tegenstelling tot het shorttype, charis het type integer niet ondertekend en kan het waarden opslaan van 0tot 65,535.

Het chartype is een hybride type. De waarden kunnen zowel als getallen worden geïnterpreteerd (ze kunnen bijvoorbeeld worden opgeteld en vermenigvuldigd) als als tekens. Dit werd gedaan omdat, hoewel karakters visuele representaties zijn, ze voor een computer vooral cijfers zijn. En het is veel handiger om ermee te werken als cijfers.

Unicode

Unicode is een speciale tabel (codering) die alle tekens ter wereld bevat. En elk personage heeft zijn eigen nummer. Het ziet er ongeveer zo uit:

Er zijn verschillende manieren om een ​​waarde toe te kennen aan een charvariabele.

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

Meestal geven mensen het teken eenvoudig tussen aanhalingstekens aan (zoals in de eerste rij van de tabel). Dat gezegd hebbende, de laatste methode is ook populair. Het voordeel is dat het in strings kan worden gebruikt.

En zoals we al zeiden, het chartype is ook een geheel getal, dus je kunt zoiets als dit schrijven:

char a = 'A';
a++;
System.out.println(a);

Werken met chars

Elk charis allereerst een nummer (tekencode) en vervolgens een teken. Als u een tekencode kent, kunt u het teken altijd in uw programma krijgen. Voorbeeld:

char c = (char) 1128;
System.out.println(c);

Ѩ

Standaard codes

Dit zijn de meest bekende karaktercodes:

6. booleantypen

En het laatste primitieve type is boolean.

Zoals u al weet, kan het slechts twee waarden aannemen: trueen false.

En daarmee weet je al alles wat er te weten valt over dit type.