# Java-primitiivien käyttö Java-kielessä on 8 primitiivistä tietotyyppiä, joilla kaikilla on kiinteä koko ja määritelty arvoalue. Niitä käytetään muuttujien luomiseen ja niille yksilöllisten numeroiden, merkkien tai loogisten arvojen määrittämiseen. Java-kielen 8 primitiivistä tietotyyppiä ovat boolean, byte, char, double, float, int, long ja short. ## Mitä ovat Java-primitiivit? Muiden ohjelmointikielien tavoin Java-kielessä on erilaisia [tietotyyppejä](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-tietotyypit/). Java-kielessä ne jaetaan kahteen luokkaan. Ensimmäinen on viitetyypit, jotka viittaavat vapaasti määriteltävään objektiin, kuten merkkijonoihin, taulukoihin, luokkiin ja rajapintoihin. Toinen on Java-primitiivien luokka. Niillä on **kiinteä koko**, joka on sama kaikilla alustoilla. Niillä on myös oma **wrapper-luokka**, ne ovat **muuttumattomia** ja niillä on **kiinteä arvoalue**. Java-primitiivejä käytetään yksittäisten numeroiden, merkkien tai loogisten arvojen muuttujien luomiseen. Java-kielessä on 8 erilaista primitiivistä tietotyyppiä, jotka eroavat toisistaan pääasiassa **tallentamiensa arvojen** suhteen. Niille kaikille on yhteistä, että ne voivat sisältää vain yhden arvon. Koska joitakin niistä käytetään samankaltaisissa tilanteissa, voimme jakaa Java-primitiivit neljään luokkaan: - Looginen tietotyyppi (boolean) - Integroitu tietotyyppi (byte, short, int ja long) - Liukulukuinen tietotyyppi (float ja double) - Merkki-tietotyyppi (char) Koska ne tallennetaan suoraan pinoon, niiden koot ovat erityisen tärkeitä. Käsittelemme tätä tarkemmin myöhemmin tässä oppaassa. Java-primitiivit ovat tärkeitä myös siksi, että Java on **staattisesti tyypitetty kieli**. Kun luot ohjelmaa, sinun on siis määriteltävä jo etukäteen, minkä tyyppinen muuttuja on kyseessä, muuten saat virheilmoituksia. Tässä on yleiskatsaus Java-primitiiveistä:
Tietotyyppi Koko Arvoalue Oletusarvo Kääreluokka
boolean 1 bitti true tai false epätosi java.lang.Boolean
bitti 8 bittiä -128–127 0 java.lang.Byte
lyhyt 16 bittiä -32768–32767 0 java.lang.Short
int 32 bittiä -2147483648 – 2147483647 0 java.lang.Integer
pitkä 64 bittiä -9223372036854775808 – 9223372036854775807 0 java.lang.Long
float 32 bittiä enintään 7 desimaalia 0,0 java.lang.Float
double 64 bittiä enintään 16 desimaalia 0,0 java.lang.Double
char 16 bittiä \*\*’\\u0000’ (eli 0) – ‘\\uffff’ (vastaa 65535) ‘\\u0000’ java.lang.Character
## Java-primitiivisen boolean-tyypin käyttö [Java-booli](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-kielen-boolean-primitiivinen-tietotyyppi/) tunnetaan myös nimellä totuusarvo. Se on yksinkertaisin Java-primitiivinen tyyppi, sillä sillä on vain kaksi mahdollista arvoa: **”true” tai ”false”.** Sitä käytetään, kun tarvitaan loogista operandia, ja se on ainoa looginen tietotyyppi. Lausekkeissa sen kaksi mahdollista arvoa edustavat yleensä ehtoa, joka joko täyttyy (true) tai ei täyty (false). Jos et määritä Boolean-tyypille arvoa, sen oletusarvona on false. Boolean-tyyppiä voidaan yhdistää Java-kielessä Boolean-operaattoreihin, kuten [AND ja OR](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-operators-and-or/). Arvon määrittäminen Boolean-tyypille tapahtuu seuraavasti: ```java public class Main { public static void main(String[] args) { boolean x = true; System.out.println(x); } } ``` Jos käytät Java-komentoa `System.out.prinln` tulostuksen alustamiseen, tulostus näyttää tältä: ```java true ``` ## tavu byte on pienin tietotyyppi kokonaislukutyyppien joukossa. Sen arvoalue on hyvin rajoitettu, nimittäin \*\*-128:\*\*sta **127:ään**. Se käyttää kuitenkin vain 8 bittiä muistia. Itse asiassa se on saanut nimensä siitä, että 8 bittiä muodostaa yhden tavun. Jos työskentelet vain hyvin rajoitetulla arvoalueella, voit määritellä tavun seuraavasti: ```java public class Main { public static void main(String[] args) { byte x = 101; System.out.println(x); } } ``` Tulostus näyttää seuraavalta: ```java 101 ``` ## lyhyt short on **kaksi kertaa suurempi kuin byte**, mikä tarkoittaa, että se on myös yksi harvemmin käytetyistä Java-primitiiveistä. Mutta jos byte on liian pieni ja int liian suuri, short saattaa olla etsimäsi kokonaislukutyyppi. Näin se määritellään: ```java public class Main { public static void main(String[] args) { short x = -27412; System.out.println(x); } } ``` Tulostus näyttää tältä: ```java -27412 ``` ## int int on **useimmin käytetty** kokonaislukutyyppi. Sen arvoalue on erittäin laaja, mutta se säästää silti tilaa. int on kahden komplementin arvo, jota käytetään usein myös muihin tarkoituksiin. Näin sitä käytetään: ```java public class Main { public static void main(String[] args) { int x = 14; int y = 3; int z = x + y; System.out.println(x + " + " + y + " = " + z); } } ``` Tulostus näyttää seuraavalta: ```java 14 + 3 = 17 ``` ## pitkä long on int-tyypin laajennus ja voi sisältää **vielä pidempiä lukuja**. int riittää useimmissa tapauksissa, mutta jos haluat määritellä long-tyypin, voit tehdä sen seuraavasti: ```java public class Main { public static void main(String[] args) { long x = 47; System.out.println(x); } } ``` Tässä on tulos: ```java 47 ``` ## kellua Järkevien lukujen osajoukkojen esittämiseen on kaksi Java-primitiiviä. float on pienempi kahdesta **liukuluvutyypistä** ja käyttää 32 bittiä. Se voi näyttää enintään 7 desimaalia. Se ei kuitenkaan ole kovin tarkka, joten sitä ei käytetä kovin usein. Jos päätät käyttää sitä, voit määrittää sen seuraavasti: ```java public class Main { public static void main(String[] args) { float x = 7.22f; System.out.println(x); } } ``` Huomaa, että numeron jälkeen on lisättävä pieni tai iso f-kirjain, jotta tietokone tunnistaa sen float-tyyppiseksi eikä double-tyyppiseksi. F-kirjainta ei näytetä tulosteessa: ```java 7.22 ``` ## kaksinkertainen Toinen liukulukuinen tietotyyppi on double. Se on huomattavasti tarkempi kuin float, mutta ei silti palauta täysin tarkkoja tuloksia. Jos etsit vaihtoehtoa, voit käyttää **BigDecimal-luokkaa**. Jos double sopii tarkoitukseesi, voit määrittää sen seuraavasti: ```java public class Main { public static void main(String[] args) { double x = 7.2252; System.out.println(x); } } ``` Huomaa, että tässä ei ole ylimääräistä kirjainta. Tulostus näyttää seuraavalta: ```java 7.2252 ``` ## hahmo char-tyyppiä käytetään Unicode-merkkien esittämiseen. Sen arvoalue on ‘\\u0000’ – ‘\\uffff’, eli 0 – 65535. Merkkityyppi voi esittää lähes kaikki **eurooppalaiset ja aasialaiset merkit**. Se käyttää 16 bittiä muistia. Tämän Java-primitiivisen tyypin arvot asetetaan yksittäisiin lainausmerkkeihin. Näin se näyttää koodissa: ```java public class Main { public static void main(String[] args) { char x = '&'; System.out.println(x); } } ``` Tulostus näyttää seuraavalta: ```java & ``` This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-primitiivit/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-primitiivit/) for AI/LLM consumption.