int, long, short și byte în Java

byte b = 100;          // 8 biți: -128 .. 127
short s = 30_000;      // 16 biți
int i = 2_000_000;     // 32 biți
long l = 9_000_000_000L; // 64 biți

Ce face int, long, short și byte

Java are patru tipuri primitive pentru numere întregi, toate cu semn: byte (8 biți, −128..127), short (16 biți, −32.768..32.767), int (32 de biți, aproximativ ±2,1 miliarde) și long (64 de biți, aproximativ ±9,2·10¹⁸).

int este tipul implicit: un literal ca 42 este int. Pentru long adaugi sufixul L. Literalii pot fi scriși și în hexazecimal (0xFF), binar (0b1010) sau octal (017), iar _ grupează cifrele.

Împărțirea între întregi taie zecimalele (7 / 2 este 3), iar % dă restul. Dacă rezultatul depășește limita tipului, valoarea „se dă peste cap” fără nicio eroare (overflow). Math.addExact și metodele înrudite aruncă excepție în acest caz.

În expresii, byte și short sunt transformate automat în int, de aceea byte c = a + b; nu compilează fără cast.

Parametri

Parametru	Descriere
byte	−128 .. 127. Folosit pentru date binare (fișiere, rețea).
short	−32.768 .. 32.767. Rar folosit.
int	−2.147.483.648 .. 2.147.483.647. Tipul obișnuit pentru întregi.
long	−9.223.372.036.854.775.808 .. 9.223.372.036.854.775.807. Pentru sume mari, milisecunde, ID-uri.

Exemple

Exemplul 1: Operații cu întregi

/ între întregi dă tot un întreg. Pentru media cu zecimale, unul dintre operanzi trebuie să fie double.

public class Main {
    public static void main(String[] args) {
        int bomboane = 17;
        int copii = 5;
        System.out.println("Fiecare copil primește " + bomboane / copii);
        System.out.println("Rămân " + bomboane % copii);

        int suma = 10 + 9 + 9;
        System.out.println("medie greșită: " + suma / 3);
        System.out.println("medie corectă: " + (double) suma / 3);

        System.out.println("hex 0xFF = " + 0xFF + ", binar 0b1010 = " + 0b1010);
    }
}

Rezultat

Fiecare copil primește 3
Rămân 2
medie greșită: 9
medie corectă: 9.333333333333334
hex 0xFF = 255, binar 0b1010 = 10

Exemplul 2: Overflow și long

Produsul depășește limita lui int și dă un rezultat negativ, fără eroare. Cu long (observă L) calculul este corect, iar Math.multiplyExact semnalează depășirea.

public class Main {
    public static void main(String[] args) {
        int secundePeAn = 365 * 24 * 60 * 60;
        System.out.println("secunde într-un an: " + secundePeAn);

        int gresit = secundePeAn * 100;
        System.out.println("într-un secol (int): " + gresit);

        long corect = secundePeAn * 100L;
        System.out.println("într-un secol (long): " + corect);

        try {
            Math.multiplyExact(secundePeAn, 100);
        } catch (ArithmeticException e) {
            System.out.println("multiplyExact: " + e.getMessage());
        }
    }
}

Rezultat

secunde într-un an: 31536000
într-un secol (int): -1141367296
într-un secol (long): 3153600000
multiplyExact: integer overflow

Exemplul 3: byte și short în expresii

a + b are tipul int, deci trebuie cast înapoi la byte. Operatorul compus += face cast-ul singur.

public class Main {
    public static void main(String[] args) {
        byte a = 100;
        byte b = 20;
        byte c = (byte) (a + b);   // fără cast: eroare de compilare
        System.out.println("c = " + c);

        short pasi = 30_000;
        pasi += 2_000;             // += face cast-ul automat
        System.out.println("pași = " + pasi);

        System.out.println("byte maxim + 1 = " + (byte) (Byte.MAX_VALUE + 1));
    }
}

Rezultat

c = 120
pași = 32000
byte maxim + 1 = -128

Greșeli frecvente

• 7 / 2 dă 3, nu 3.5: ambii operanzi sunt întregi.
• Calcule mari în int care depășesc ±2,1 miliarde (de exemplu milisecunde sau bani în bani) și dau rezultate negative: folosește long.
• Un literal care începe cu 0 este octal: 010 înseamnă 8.

Comenzi înrudite

• Variabile și tipuri primitive: O variabilă are un tip fix, declarat la creare; Java are 8 tipuri primitive: byte, short, int, long, float, double, char, boolean.
• double și float: Tipurile pentru numere cu virgulă: double (64 de biți, implicit) și float (32 de biți, literal cu sufixul f).
• Operatori: Operatorii aritmetici, de comparație, logici, de atribuire, ternar și pe biți din Java, cu ordinea lor de evaluare.
• Tipuri wrapper și autoboxing: Fiecare primitiv are o clasă „înveliș” (Integer, Double, Character…); conversia automată între ele se numește autoboxing.