Какая размерность типа int?

Размерность типа int в Java

Это базовый, но важный вопрос, который проверяет знание типов данных в Java. Ответ точный и стандартизированный.

Основная информация

int в Java занимает ровно 4 байта (32 бита)

Это определено спецификацией Java Language Specification (JLS) и одинаково на всех платформах (Windows, Linux, Mac, и т.д.).

public class IntSizeDemo {
    public static void main(String[] args) {
        // Размер int — 4 байта
        System.out.println("Integer.BYTES: " + Integer.BYTES);  // 4
        
        // Или через reflection (не рекомендуется)
        int sizeInBits = Integer.SIZE;  // 32 bits
        int sizeInBytes = Integer.SIZE / 8;  // 4 bytes
        
        System.out.println("Integer.SIZE: " + Integer.SIZE);  // 32 bits
        System.out.println("Bytes: " + sizeInBytes);  // 4 bytes
    }
}

Диапазон значений int

int — знаковый тип (signed). Диапазон: от -2^31 до 2^31 - 1

public class IntRangeDemo {
    public static void main(String[] args) {
        System.out.println("Min value: " + Integer.MIN_VALUE);  // -2147483648
        System.out.println("Max value: " + Integer.MAX_VALUE);  //  2147483647
        
        // Это 4 294 967 296 возможных значений (2^32)
        // Один бит зарезервирован для знака
    }
}

Сравнение с другими типами

public class TypeComparisonDemo {
    public static void main(String[] args) {
        // Примитивные типы в Java (размеры в байтах):
        byte b = 0;          // 1 байт (8 бит)
        short s = 0;         // 2 байта (16 бит)
        int i = 0;           // 4 байта (32 бита) ← ВОПРОС
        long l = 0L;         // 8 байт (64 бита)
        float f = 0.0f;      // 4 байта (32 бита)
        double d = 0.0;      // 8 байт (64 бита)
        char c = '0';        // 2 байта (16 бит, Unicode)
        boolean bool = true; // 1 байт в объекте
        
        // Вывести размеры
        System.out.println("byte: " + Byte.BYTES);        // 1
        System.out.println("short: " + Short.BYTES);      // 2
        System.out.println("int: " + Integer.BYTES);      // 4
        System.out.println("long: " + Long.BYTES);        // 8
        System.out.println("float: " + Float.BYTES);      // 4
        System.out.println("double: " + Double.BYTES);    // 8
    }
}

Таблица примитивных типов

Тип | Размер | Диапазон | Знаковый byte | 1 байт | -128 до 127 | Да short | 2 байта | -32768 до 32767 | Да

int | 4 байта | -2147483648 до 2147483647 | Да

long | 8 байт | очень большой диапазон | Да float | 4 байта | приблизительный | Да (IEEE 754) double | 8 байт | приблизительный | Да (IEEE 754) char | 2 байта | 0 до 65535 | Нет (unsigned)

Переполнение (Overflow)

public class OverflowDemo {
    public static void main(String[] args) {
        // int переполняется (wrap around)
        int maxInt = Integer.MAX_VALUE;  // 2147483647
        System.out.println("Max: " + maxInt);
        
        int overflow = maxInt + 1;
        System.out.println("Max + 1: " + overflow);  // -2147483648 (минимум!)
        // Это циклическое переполнение (wraparound)
    }
}

Практические примеры

public class IntPracticalExamples {
    public static void main(String[] args) {
        // 1. Литерал int
        int decimal = 100;
        int octal = 0144;        // 100 в восьмеричной
        int hex = 0x64;          // 100 в шестнадцатеричной
        int binary = 0b1100100;  // 100 в двоичной
        
        // 2. Явное приведение типов
        byte b = 100;
        int i = b;  // Автоматическое расширение (widening)
        
        int j = 100000;
        byte b2 = (byte) j;  // Явное сужение (narrowing) — может потерять данные
        
        // 3. Целочисленные операции
        int a = 10 / 3;     // 3 (целочисленное деление)
        int remainder = 10 % 3;     // 1 (остаток)
        
        // 4. Побитовые операции
        int bits = 5;         // 0101
        System.out.println(bits << 1);  // 10 (сдвиг влево)
        System.out.println(bits >> 1);  // 2 (сдвиг вправо)
        System.out.println(bits & 3);   // 1 (побитовое И)
        System.out.println(bits | 3);   // 7 (побитовое ИЛИ)
    }
}

Неизменяемость размера в Java

Это ключевое преимущество Java:

• В C/C++: int может быть 2, 4 или 8 байт в зависимости от платформы
• В Java: int ВСЕГДА 4 байта, независимо от ОС и архитектуры

Это обеспечивает Write Once, Run Anywhere (WORA).

Использование Integer вместо int

public class IntegerVsInt {
    public static void main(String[] args) {
        // int — примитивный тип (не объект)
        int primitive = 100;  // Занимает 4 байта
        
        // Integer — wrapper класс (объект)
        Integer object = 100;  // Занимает 4 байта + overhead объекта
        
        // Integer имеет полезные константы и методы
        System.out.println(Integer.MIN_VALUE);  // -2147483648
        System.out.println(Integer.MAX_VALUE);  // 2147483647
        System.out.println(Integer.BYTES);      // 4
        System.out.println(Integer.SIZE);       // 32
        
        // Integer можно использовать в Collections
        List<Integer> list = new ArrayList<>();  // нельзя List<int>
        list.add(100);
        
        // Автобоксинг (автоматическое преобразование int к Integer)
        Integer boxed = 100;      // int к Integer
        int unboxed = boxed;      // Integer к int
    }
}

Итоговый ответ

int в Java:

• Размер: ровно 4 байта (32 бита)
• Диапазон: от -2,147,483,648 до 2,147,483,647
• Тип: знаковый целочисленный
• Стандарт: определён Java Language Specification
• Платформозависимость: нет (одинаков везде)

Это фундаментальное знание, необходимое каждому Java-разработчику!