Celé číslo int, Integer (java.lang)

Primitívny typ "int" predstavuje 32-bitové celé číslo so znamienkom. To znamená celé číslo medzi -231 a 231-1, čiže medzi -2_147_483_648 a 2_147_483_647.

Toto je štandardný celočíselný typ; mali by sme ho používať vo väčšine prípadov, keď pracujeme s celými číslami. Ak vieme, že rozsah plusmínus dve miliardy nebude stačiť, použijeme "long" alebo BigInteger. Ak pracujeme s veľkými poľami čísel a chceme šetriť pamäť, použijeme "short" alebo "byte". (Z hľadiska rýchlosti sa však typy "short" a "byte" neoplatia, lebo všetky číselné výpočty sa interne počítajú ako "long" alebo "int".)

Konverzia typu

Tu je prehľad metód, pomocou ktorých môžeme získať premennú iného typu:

Máme typChceme typKódPoznámka
intInteger
Integer objI = Integer.valueOf(i);
 
Integer objI = i; // autoboxing
Integerint
int i = objI.intValue();
pozor na null*
int i = objI; // autounboxing
byteint
int i = b;
 
Byteint
int i = objB.intValue();
pozor na null*
intbyte
byte b = (byte) i;
menší rozsah**
Integerbyte
byte b = objI.byteValue();
pozor na null*; menší rozsah**
shortint
int i = s;
 
Shortint
int i = objS.intValue();
pozor na null*
intshort
short s = (short) i;
menší rozsah**
Integershort
short s = objI.shortValue();
pozor na null*; menší rozsah**
longint
int i = (int) l;
menší rozsah **
Longint
int i = objL.intValue();
pozor na null*; menší rozsah**
intlong
long l = i;
 
Integerlong
long l = objI.longValue();
pozor na null*
Stringint
int i = Integer.parseInt(s);
reťazec môže obsahovať iba číslice 0 až 9 a prípadne znamienko "-" na začiatku, nesmie byť prázdny ani null, a výsledok sa musí zmestiť do rozsahu typu int, inak nastane NumberFormatException
int i = Integer.parseInt(s, 16);
to isté, ale v inej ako desiatkovej číselnej sústave; po čísliciach 0 až 9 nasledujú písmená (veľké alebo malé); najväčší možný základ číselnej sústavy je 36
int i = Integer.decode(s);
reťazce začínajúce "0x", "0X", "#" sa preložia ako šestnástkové čísla, reťazce začínajúce "0" ako osmičkové, zvyšné reťazce ako desiatkové
intString
String s = String.valueOf(i);
 
String s = "" + i;
String s = Integer.toString(i);
String s = Integer.toBinaryString(i);
zápis v dvojkovej sústave
String s = Integer.toOctalString(i);
zápis v osmičkovej sústave
String s = Integer.toHexString(i);
zápis v šestnástkovej sústave
String s = Integer.toString(i, 16);
zápis v inej číselnej sústave
IntegerString
String s = objI.toString();
pozor na null*
String s = "" + objI;
 

Poznámky:

* Pozor na null: Premenná objektového typu môže obsahovať aj hodnotu "null". Ak v takom prípade zavoláme jej metódu (hoci aj implicitne cez autounboxing), nastane výnimka "NullPointerException".

Ak sa chceme vyhnúť výnimke, musíme v kóde ošetriť túto možnosť osobitne. Napríklad ak chceme z hodnoty typu "Integer" urobiť hodnotu typu "int" tak, že prípadnú hodnotu "null" chceme premeniť na číslo 0, napíšeme:

int i = (null == objI) ? 0 : objI.intValue();
int i = (null == objI) ? 0 : objI; // autounboxing

** Menší rozsah: Typy "byte" a "short" pokrývajú menší rozsah hodnôt než "int"; typ "int" pokrýva menší rozsah hodnôt než "long". Pri konverzii z väčšieho typu na menší sa z pôvodnej hodnoty skopíruje príslušný počet najnižších bitov do cieľovej hodnoty, a zvyšné bity sa jednoducho vynechajú. Ak je pôvodné číslo v rozsahu cieľového typu, zostane rovnaké. Ak je mimo tohto rozsahu, vynechaním bitov sa zmení jeho hodnota. Táto hodnota môže spôsobiť aj zmenu znamienka, z kladného čísla na záporné alebo zo záporného na kladné.

Príklad: číslo 2000 sa do premennej typu "int" uloží ako bity 00000000 00000000 00000111 11010000. Pri konverzii na typ "short" zostanú bity 00000111 11010000, ktoré stále kódujú hodnotu 2000. Pri konverzii na typ "byt" však zostanú iba bity 11010000, ktoré kódujú hodnotu -48.

viliam@bur.sk