В чем разница между объектом и примитивом?

# Разница между объектом и примитивом в Java

Основное определение

В Java существует фундаментальное различие между примитивными типами (primitives) и объектами (objects). Это различие касается хранения, производительности, функциональности и поведения.

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

Примитивные типы - это встроенные базовые типы данных, которые хранят значения напрямую в памяти (обычно в стеке).

В Java есть 8 примитивных типов:

// Числовые типы
byte b = 10;           // 1 байт (-128 до 127)
short s = 1000;        // 2 байта
int i = 100000;        // 4 байта (по умолчанию для чисел)
long l = 10000000000L; // 8 байт

// Числа с плавающей точкой
float f = 3.14f;       // 4 байта
double d = 3.14159;    // 8 байт (по умолчанию для decimal)

// Булево значение
boolean flag = true;   // 1 бит (в JVM занимает 1 байт)

// Символ
char c = 'A';          // 2 байта (Unicode)

Характеристики примитивов:

• Хранят значение напрямую
• Размер фиксирован
• Обычно находятся в стеке
• Очень быстро
• Нет методов
• Не наследуемы
• Сравнение через == сравнивает значения

Объекты

Объекты - это экземпляры классов, которые хранят ссылку на данные в heap памяти.

// Объекты
String str = "Hello";     // Объект String на heap
Integer num = 42;         // Объект Integer на heap
ArrayList<String> list = new ArrayList<>(); // Объект ArrayList на heap
MyClass obj = new MyClass(); // Объект пользовательского класса

Характеристики объектов:

• Хранят ссылку на данные
• Размер зависит от класса
• Находятся на heap
• Может быть медленнее (через ссылку)
• Имеют методы
• Наследуемы
• Сравнение через == сравнивает ссылки (использовать equals())
• Управляются сборщиком мусора (GC)

Таблица сравнения

Визуальное представление в памяти

Примитив (int):
┌─────────────────┐
│ Stack           │
│  i = 42         │ (значение 42 прямо в стеке)
└─────────────────┘

Объект (Integer):
┌──────────────┐          ┌────────────────┐
│ Stack        │          │ Heap           │
│ num ────────────────→ │ Integer(42)    │
└──────────────┘          │ value: 42      │
                         └────────────────┘

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

Пример 1: Сравнение

// Примитивы - сравниваются по значению
int a = 10;
int b = 10;
System.out.println(a == b); // true (значения одинаковые)

// Объекты - сравниваются по ссылке (если не переопределен equals)
Integer x = new Integer(10);
Integer y = new Integer(10);
System.out.println(x == y);      // false (разные объекты)
System.out.println(x.equals(y));  // true (одинаковое значение)

Пример 2: null

// Примитив не может быть null
int i = null; // ❌ Ошибка компиляции

// Объект может быть null
Integer i = null; // ✅ Допустимо
String str = null; // ✅ Допустимо

if (str == null) {
    System.out.println("String is null");
}

Пример 3: Производительность

// Примитивы - быстро
int[] primitiveArray = new int[1_000_000];
for (int i = 0; i < 1_000_000; i++) {
    primitiveArray[i] = i * 2;
}
// ~1-2ms

// Объекты - медленнее (из-за выделения памяти и GC)
Integer[] objectArray = new Integer[1_000_000];
for (int i = 0; i < 1_000_000; i++) {
    objectArray[i] = i * 2; // Создается новый Integer объект
}
// ~10-20ms + работа GC

Пример 4: Методы

// Примитив - нет методов
int x = 42;
// x.toString(); // ❌ Ошибка

// Объект - есть методы
Integer x = 42;
String str = x.toString(); // ✅ "42"
int value = x.intValue();  // ✅ 42

Autoboxing и Unboxing

Java автоматически конвертирует примитивы в объекты и обратно:

// Autoboxing - примитив → объект
int primitiveInt = 42;
Integer objectInt = primitiveInt; // Автоматически создается Integer(42)

// Unboxing - объект → примитив
Integer boxedInt = 42;
int unboxedInt = boxedInt; // Автоматически извлекается значение 42

// Это работает и в более сложных случаях
List<Integer> list = new ArrayList<>();
list.add(10); // Autoboxing: 10 → Integer(10)
int value = list.get(0); // Unboxing: Integer(10) → 10

Осторожно с null при unboxing:

Integer num = null;
int x = num; // ❌ NullPointerException!

// Правильный способ
Integer num = null;
int x = num != null ? num : 0; // Безопасно

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

Используйте примитивы когда:

// 1. Высокие требования к производительности
public void processMillionNumbers(int[] numbers) {
    for (int num : numbers) {
        // Работа с примитивом - быстро
    }
}

// 2. Нужно экономить память
int[] pixels = new int[1920 * 1080]; // 8MB для примитивов
// Integer[] pixels - 32MB+ для объектов

// 3. Нужно исключить null
public int calculateSum(int[] numbers) {
    // Гарантированно, что нет null значений
}

Используйте объекты когда:

// 1. Нужны методы
String text = "Hello".toUpperCase();
Integer num = 42;
String formatted = num.toString();

// 2. Нужна null поддержка
Integer result = null;
if (result != null) {
    // Работа
}

// 3. Нужна полиморфизм и наследование
List<Number> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(3.14);
numbers.add(new BigDecimal("100.50"));

// 4. Нужна коллекция
List<Integer> list = new ArrayList<>(); // Только объекты
int[] array = {1, 2, 3};                // Примитивы не подходят

Boxing типы

Для каждого примитива есть соответствующий класс-обертка:

byte    ↔ Byte
short   ↔ Short
int     ↔ Integer
long    ↔ Long
float   ↔ Float
double  ↔ Double
boolean ↔ Boolean
char    ↔ Character

Выводы

1. Примитивы - быстрые, простые, без методов, без null, находятся в стеке
2. Объекты - медленнее, полнофункциональные, поддерживают null, находятся на heap
3. Autoboxing позволяет использовать примитивы и объекты взаимозаменяемо
4. Выбирайте примитивы для производительности и памяти
5. Выбирайте объекты для функциональности и полиморфизма
6. Коллекции требуют объекты, поэтому используйте типы-обертки
7. Будьте осторожны с null при unboxing