Могут ли обобщения работать с примитивными типами данных

# Могут ли generics работать с примитивными типами

Короткий ответ: НЕТ. Generics работают только с reference types (объекты), не с примитивами.

Почему нет

1. Type Erasure

Geneics в Java реализованы через type erasure — стирание типов во время компиляции:

// Это пишешь ты:
List<String> list = new ArrayList<String>();

// А компилятор превращает в это (во время компиляции):
List list = new ArrayList(); // Тип <String> СТИРАЕТСЯ!

Это сделано для обратной совместимости со старым Java кодом (Java 1.4 и ниже не было generics).

2. Коробки класса параметры требуют объекты

// Это НЕ работает:
List<int> numbers = new ArrayList<int>(); // ОШИБКА КОМПИЛЯЦИИ!

// Нужно использовать wrapper:
List<Integer> numbers = new ArrayList<Integer>(); // OK

Почему? Потому что JVM хранит references на объекты, а примитивы — просто значения в памяти.

Низкоуровневые причины

Примитивы (int, long, boolean) — это НЕ объекты:

int x = 5;        // Просто число в памяти
Integer obj = 5;  // Объект, обёртка вокруг числа

Genericss require objects because:

• JVM Virtual Machine работает с ссылками на объекты
• Примитивы не имеют методов (нет null у int)
• Нет виртуального dispatch для примитивов

Решение: Wrapper classes

Для работы с примитивами используй wrapper classes:

primitive type  →  wrapper class
     int        →  Integer
     long       →  Long
     double     →  Double
     boolean    →  Boolean
     byte       →  Byte
     short      →  Short
     float      →  Float
     char       →  Character

Пример

// ❌ НЕПРАВИЛЬНО
public class Box<T> {
    private T value;
    
    public Box(int value) { } // НЕ СКОМПИЛИРУЕТСЯ с T = int
}

// ✅ ПРАВИЛЬНО
public class Box<T> {
    private T value;
    
    public Box(T value) {
        this.value = value;
    }
}

// Использование:
Box<Integer> intBox = new Box<>(42);      // ✅ Автобоксинг
Box<String> strBox = new Box<>("hello");  // ✅
Box<Double> dblBox = new Box<>(3.14);     // ✅ Автобоксинг

Автобоксинг и разбоксинг

Java автоматически конвертирует примитив ↔ wrapper:

// Автобоксинг: примитив → объект
Integer num = 5;        // int → Integer
List<Integer> list = new ArrayList<>();
list.add(10);           // int → Integer (автоматически)

// Разбоксинг: объект → примитив
int value = num;        // Integer → int (автоматически)
int sum = 5 + num;      // num разбоксится в int

Внутри

// Что ты пишешь:
Integer wrapped = 42;

// Что компилятор генерирует:
Integer wrapped = Integer.valueOf(42); // Автобоксинг

int unwrapped = wrapped;               // Разбоксинг
// становится:
int unwrapped = wrapped.intValue();    // Явный разбоксинг

Проблемы с wrappers

1. Производительность

List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    list.add(i);        // Каждое число становится объектом Integer
}

// Результат: 1 млн объектов Integer в памяти
// Потеря памяти, медленнее, чем массив int

2. Null указатели

Integer value = null;      // OK для Integer
int primitive = value;     // NullPointerException!

// С обычным int:
int x = null;              // ОШИБКА КОМПИЛЯЦИИ

3. Поиск ошибок

List<Integer> numbers = Arrays.asList(1, 2, null, 4);

for (Integer num : numbers) {
    int sum = num + 10;    // NullPointerException на null
}

Когда это критично

Низкоуровневая работа с данными

// Обработка больших объёмов примитивов
int[] rawData = new int[1_000_000_000];

// Если ты напишешь List<Integer>, это:
// - Потребит 8x больше памяти (reference overhead)
// - Медленнее работает (разыменования)
// - Может вызвать OutOfMemoryError

Решение: использование примитивных массивов

int[] data = new int[1_000_000_000];  // Обычный массив
data[0] = 42;                         // Нет allocation объектов

Java 8+ Streams с примитивами

// ❌ Неэффективно: boxed Integer
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
numbers.stream()
    .map(n -> n * 2)
    .forEach(System.out::println);

// ✅ Эффективно: примитивный stream
int[] numbers = {1, 2, 3, 4, 5};
Arrays.stream(numbers)
    .map(n -> n * 2)
    .forEach(System.out::println);

// Или IntStream
IntStream.range(0, 5)
    .map(n -> n * 2)
    .forEach(System.out::println);

Примитивные генерики в других языках

C++ (specialization)

template<typename T>
class Box { ... };

// C++ может specialízировать для int
template<>
class Box<int> { ... }; // Отдельная реализация

C# (reified generics)

List<int> numbers = new List<int>(); // ✅ Работает!
// C# сохраняет информацию о типе во время выполнения

Java не может этого делать из-за type erasure (для совместимости).

Лучшие практики

1. Для коллекций маленькие объёмы

List<Integer> userIds = new ArrayList<>();     // OK, маленьких ID
List<String> names = new ArrayList<>();        // OK

2. Для больших объёмов примитивов

private int[] largeDataset = new int[10_000_000];

// Не List<Integer>, а массив int!
public int getSum() {
    int sum = 0;
    for (int value : largeDataset) {
        sum += value;
    }
    return sum;
}

3. Для performance-critical кода

// Использование IntStream вместо Stream<Integer>
long sum = IntStream.range(0, numbers.length)
    .map(i -> numbers[i])
    .sum();

// Вместо
long sum = Arrays.stream(numbers)  // Это Stream<Integer>
    .mapToInt(i -> i)              // Конвертируем в IntStream
    .sum();

Табличка: что использовать

Итог

Generics НЕ работают с примитивами:
- Type erasure стирает информацию о типе
- JVM работает с ссылками на объекты
- Нужно использовать Wrapper classes (Integer, Long и т.д.)

Автобоксинг скрывает конвертацию:
- List<Integer> list; list.add(5); // 5 становится Integer.valueOf(5)

Для высокой производительности:
- Используй примитивные массивы или IntStream
- Избегай List<Integer> для миллионов элементов