Сколько байт занимает int?

Сколько байт занимает int?

Быстрый ответ

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

Это задано спецификацией Java Language Specification (JLS). В отличие от C++, где размер int зависит от платформы, в Java он всегда одинаков.

Проверка в коде

public class IntSize {
    public static void main(String[] args) {
        // Размер в битах
        System.out.println(Integer.SIZE); // 32
        
        // Размер в байтах
        System.out.println(Integer.SIZE / 8); // 4
        
        // Или через Integer.BYTES (Java 8+)
        System.out.println(Integer.BYTES); // 4
        
        // Диапазон значений
        System.out.println(Integer.MIN_VALUE); // -2,147,483,648
        System.out.println(Integer.MAX_VALUE); // 2,147,483,647
    }
}

Примитивные типы и их размеры

Тип       | Размер      | Диапазон
----------|-------------|----------------------------------
byte      | 1 байт (8)  | -128 до 127
short     | 2 байта (16)| -32,768 до 32,767
int       | 4 байта (32)| -2^31 до 2^31-1 (~2.1 млрд)
long      | 8 байт (64) | -2^63 до 2^63-1
float     | 4 байта (32)| IEEE 754 single precision
double    | 8 байт (64) | IEEE 754 double precision
char      | 2 байта (16)| 0 до 65,535 (UTF-16)
boolean   | 1 байт      | true/false (зависит от реализации)

Важное уточнение: JVM vs Heap

Разница между переменной на стеке и объектом на heap'е:

// На стеке (stack frame)
int x = 5; // 4 байта

// На heap'е (как поле объекта)
Integer y = 5; // Integer объект занимает БОЛЬШЕ!

Размер Integer объекта:

import org.openjdk.jol.core.VM;
import org.openjdk.jol.info.ClassLayout;

public class IntegerSize {
    public static void main(String[] args) {
        // Нужна зависимость: org.openjdk.jol:jol-core
        
        System.out.println(ClassLayout.parseInstance(new Integer(5)).toPrintable());
        // Вывод (примерно):
        // Integer object internals:
        // OFFSET  SIZE  TYPE DESCRIPTION
        //      0    12       (object header)
        //     12     4   int Integer.value
        // Instance size: 16 bytes
    }
}

Integer объект занимает ~16 байт:

• Object header: 12 байт (64-bit JVM)
• int value: 4 байта
• Выравнивание: может быть дополнительное

Поэтому использование int вместо Integer может сэкономить 12 байт на переменную!

Практический пример: Экономия памяти

public class MemorySavings {
    // Плохо: 1 млн Integer объектов
    public static void badApproach() {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            numbers.add(i); // int -> Integer (автоупаковка)
        }
        // Память: ~16 млн байт (16 MB)
    }
    
    // Лучше: примитивы в array
    public static void goodApproach() {
        int[] numbers = new int[1_000_000];
        for (int i = 0; i < 1_000_000; i++) {
            numbers[i] = i;
        }
        // Память: ~4 млн байт (4 MB) + overhead массива (~32 байта)
    }
}

Разница в памяти: 12 байт на элемент × 1М = 12 MB экономии!

Когда использовать что?

Используй int (примитив):

• Производительность критична (быстро вычисления)
• Много данных (экономия памяти)
• Массивы чисел (лучше int[] чем List<Integer>)
• Локальные переменные (стек, нет overhead)

public class Calculator {
    public int sum(int[] numbers) {
        int total = 0; // быстро
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

Используй Integer (wrapper):

• Нужен null (int не может быть null)
• Collections (List<Integer> требует объекта)
• Reflection / Generics (работают с объектами)
• Optional (Optional<Integer>)

public class UserData {
    private Integer age; // может быть null (возраст неизвестен)
    
    public Optional<Integer> getAge() {
        return Optional.ofNullable(age);
    }
}

Современная оптимизация: Project Panama + Foreign Function & Memory API

Java 19+ позволяет работать с памятью напрямую:

import java.lang.foreign.*;

public class DirectMemory {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            // Выделяем память для 1000 int'ов
            MemorySegment segment = arena.allocateArray(ValueLayout.JAVA_INT, 1000);
            
            for (int i = 0; i < 1000; i++) {
                segment.setAtIndex(ValueLayout.JAVA_INT, i, i * 2);
            }
            
            // Прямой доступ к памяти (очень быстро)
            int value = segment.getAtIndex(ValueLayout.JAVA_INT, 0);
        }
    }
}

JVM Flags для мониторинга памяти

# Запуск с измерением памяти
java -XX:+PrintObjectHistogram -XX:+PrintGCDetails MyApp

# Анализ heap dump
jmap -heap <pid>
jhat heapdump.hprof

Исторический контекст

Почему именно 32 бита?

• При создании Java (1995) это был стандарт
• Поддержка 32-bit и 64-bit процессоров
• 32 бита = 4 млрд значений (достаточно для большинства задач)
• Жёсткое фиксирование размера помогает портативности

Интересные факты

public class IntFacts {
    public static void main(String[] args) {
        // Integer cache: -128 до 127 кэшируются
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b); // true (одна ячейка памяти)
        
        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d); // false (разные объекты)
        
        // Это оптимизация JVM
    }
}