Насколько быстрее работает примитивный тип по сравнению с его оберткой

# Производительность примитивных типов vs оберток

Введение

Это часто задаваемый вопрос в Java. Примитивные типы (int, double, boolean) действительно быстрее своих оберток (Integer, Double, Boolean), но важно понимать насколько и почему.

Основные различия

Примитивные типы

• Хранятся в стеке (stack)
• Быстрый доступ
• Нет overhead'а на инстанциирование
• Нет references
• Нет null значений

Обертки (Wrapper Classes)

• Хранятся в куче (heap)
• Медленнее из-за разыменования reference
• Имеют overhead на создание объекта
• Могут быть null
• Дополнительная память (заголовок объекта)

Теория: примерные различия

В общем случае примитивный тип на 10-100 раз быстрее обертки для элементарных операций, но это зависит от:

1. Конкретной операции (чтение, запись, вычисление)
2. Оптимизации JIT компилятором
3. Работы garbage collector
4. Cache locality

Практический пример с бенчмарком

public class PrimitiveVsWrapperBenchmark {
    
    // Примитивный тип
    public static long primitiveBenchmark() {
        long sum = 0;
        int[] primitives = new int[1_000_000];
        
        for (int i = 0; i < 1_000; i++) {
            for (int j = 0; j < primitives.length; j++) {
                sum += primitives[j];
            }
        }
        return sum;
    }
    
    // Обертка
    public static long wrapperBenchmark() {
        long sum = 0;
        Integer[] wrappers = new Integer[1_000_000];
        for (int i = 0; i < wrappers.length; i++) {
            wrappers[i] = i;  // autoboxing
        }
        
        for (int i = 0; i < 1_000; i++) {
            for (Integer val : wrappers) {
                sum += val;  // unboxing
            }
        }
        return sum;
    }
    
    public static void main(String[] args) {
        // Примитивные типы
        long start = System.nanoTime();
        primitiveBenchmark();
        long primTime = System.nanoTime() - start;
        System.out.println("Primitive time: " + primTime + " ns");
        
        // Обертки
        start = System.nanoTime();
        wrapperBenchmark();
        long wrapTime = System.nanoTime() - start;
        System.out.println("Wrapper time: " + wrapTime + " ns");
        
        System.out.println("Wrapper is " + (wrapTime / (double)primTime) + "x slower");
    }
}

// Ожидаемый вывод:
// Primitive time: 500000000 ns
// Wrapper time: 5000000000 ns
// Wrapper is 10x slower

Источники производительности

1. Память и выравнивание (Memory alignment)

// Примитивный тип — 4 байта
int a = 42;

// Обертка Integer — 16 байт (на 64-битной JVM)
// - Object header: 12 байт
// - int value: 4 байта
Integer b = 42;

2. Autoboxing и Unboxing

// Autoboxing — скрытое создание объекта
Integer num = 42;  // Эквивалентно Integer.valueOf(42)

// Unboxing — извлечение значения
int val = num;     // Эквивалентно num.intValue()

// Это стоит времени!
public static void inefficientExample() {
    Integer sum = 0;  // Создаётся новый объект
    for (int i = 0; i < 1_000_000; i++) {
        sum += i;  // Unboxing + вычисление + Autoboxing
    }
}

3. Null checking и dereferencing

// С примитивом — прямой доступ
int[] arr = new int[10];
int val = arr[5];  // Быстро

// С оберткой — разыменование reference
Integer[] arr2 = new Integer[10];
Integer val2 = arr2[5];  // Может быть null, требует проверки

4. Cache и Heap fragmentation

// Примитивный тип в массиве — выровнен в памяти, лучше для кэша
int[] primitives = new int[1_000_000];

// Обертки в массиве — разреженная памяти, плохо для кэша
Integer[] wrappers = new Integer[1_000_000];

Профиль скорости

Когда разница значима

Критично — используй примитивы

// 1. Циклы с миллионами итераций
for (int i = 0; i < 10_000_000; i++) {
    int value = primitiveArray[i];  // Используй примитив
    sum += value;
}

// 2. Математические вычисления
public static double calculate(double[] values) {
    double result = 0;
    for (double val : values) {  // НЕ Double!
        result += Math.sin(val);
    }
    return result;
}

// 3. Работа с большими объёмами данных
private int[] pixels;  // Для массивов пикселей

Не критично — можно использовать обертки

// 1. Collections (автоматическое Autoboxing)
List<Integer> numbers = new ArrayList<>();  // OK, не критично
Map<String, Integer> counters = new HashMap<>();  // OK

// 2. Когда нужны null значения
Integer maybeValue = null;  // Нужна обертка

// 3. Когда нужна рефлексия
Class<?> intClass = Integer.TYPE;  // Нужна обертка

JIT оптимизация

Современный JIT компилятор может значительно сократить разницу:

// HotSpot JIT может:
// 1. Inline-ить код
// 2. Escape analysis — избежать heap allocation
// 3. Specialization — использовать примитивы при возможности

public static int calculate(Integer x, Integer y) {
    return x + y;  // JIT может преобразовать в примитивы
}

Рекомендации

1. По умолчанию используй примитивы для данных и вычислений

2. Обертки используй только когда нужно:

   • Collection (List<Integer>, Map<String, Double>)
   • Null значения
   • Рефлексия и generics
   • Boxing/unboxing минимален

3. Избегай ненужного autoboxing:

// Плохо
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;  // Много autoboxing/unboxing!
}

// Хорошо
int sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;  // Примитив
}

1. Используй специализированные коллекции:

// Если нужна максимальная производительность с большим объёмом int:
// Используй библиотеки вроде Trove, Fastutil, HPPC
IntOpenHashSet set = new IntOpenHashSet();  // Примитивные int
set.add(42);

Заключение

• Примитивы в среднем на 5-50 раз быстрее оберток для элементарных операций
• Разница критична только при:
  • Больших объёмах данных (миллионы элементов)
  • Интенсивных вычислениях
  • Критичной к производительности коде
• В большинстве business-логики разница не чувствуется
• Правильная архитектура важнее микро-оптимизаций
• Используй примитивы по умолчанию, обертки по необходимости