Для чего нужны разделения типов данных?

# Разделение типов данных в Java

Что такое разделение типов

В Java существует две основные категории типов данных, каждая со своим назначением и поведением. Правильное разделение критично для написания корректного кода.

Примитивные типы (Primitive Types)

Определение

Это встроенные типы, которые хранят значения напрямую в памяти (на стеке).

Список примитивных типов

1. Целые числа:
   - byte   (8 бит, -128 до 127)
   - short  (16 бит, -32,768 до 32,767)
   - int    (32 бита, -2^31 до 2^31-1)  ← самый используемый
   - long   (64 бита, -2^63 до 2^63-1)

2. Дробные числа:
   - float  (32 бита, одинарная точность)
   - double (64 бита, двойная точность)  ← по умолчанию

3. Символы:
   - char   (16 бит, Unicode символы)

4. Логический:
   - boolean (true/false)

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

int age = 25;              // примитивный тип
long population = 1000000L;
float price = 99.99f;
boolean isActive = true;
char letter = A;

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

// 1. Примитивы хранятся на СТЕКЕ (быстро)
int x = 10;          // x → стек

// 2. Передаются ПО ЗНАЧЕНИЮ (копируется)
int a = 5;
int b = a;
b = 10;
System.out.println(a);  // 5 (не изменился!)

// 3. Сравнение через ==
int num1 = 5;
int num2 = 5;
if (num1 == num2) {      // true
    System.out.println("Равны");
}

// 4. Не могут быть null
int value = null;  // ошибка компилятора

// 5. Операции очень быстрые
long start = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
    int result = i * 2;
}
long duration = System.nanoTime() - start;

Ссылочные типы (Reference Types)

Определение

Это объекты, которые хранят ссылку на данные в памяти (на куче). Сам объект находится в памяти, переменная содержит адрес.

Основные ссылочные типы

1. Классы (Classes)
2. Интерфейсы (Interfaces)
3. Массивы (Arrays)
4. Строки (String) — частный случай класса
5. Коллекции (List, Set, Map, etc.)

Примеры ссылочных типов

String name = "Иван";              // объект String
List<Integer> numbers = new ArrayList<>();  // коллекция
User user = new User("Петр");     // пользовательский класс
int[] array = {1, 2, 3};           // массив

Характеристики ссылочных типов

// 1. Хранятся на КУЧЕ (медленнее)
String name = new String("Иван");  // объект → куча, переменная → стек

// 2. Передаются ПО ССЫЛКЕ (копируется адрес)
User user1 = new User("Иван");
User user2 = user1;      // user2 указывает на тот же объект
user2.setName("Петр");
System.out.println(user1.getName());  // "Петр" (оба указывают на один объект!)

// 3. Сравнение через equals()
String str1 = new String("hello");
String str2 = new String("hello");
if (str1 == str2) {
    System.out.println("Одинаковые объекты");  // НЕ ВЫВЕДЕТ
}
if (str1.equals(str2)) {
    System.out.println("Одинаковое содержимое");  // ВЫВЕДЕТ
}

// 4. Могут быть null
String value = null;  // OK
if (value == null) {
    System.out.println("Значение не установлено");
}

// 5. Требуют инициализации (new)
User user = null;              // OK
User user2 = new User();       // OK
User user3;                    // ошибка при использовании

Класс-обёртка (Wrapper Classes)

Для каждого примитива есть ссылочный аналог:

Примитив → Обёртка
byte     → Byte
short    → Short
int      → Integer
long     → Long
float    → Float
double   → Double
char     → Character
boolean  → Boolean

Зачем нужны обёртки

// 1. Использование в коллекциях (примитивы не подходят)
List<Integer> numbers = new ArrayList<>();  // нужна Integer, не int
numbers.add(5);
numbers.add(null);  // можно хранить null

// 2. Вызов методов
Integer num = 10;
System.out.println(num.toString());       // toString()
System.out.println(Integer.MAX_VALUE);    // MAX_VALUE
System.out.println(Integer.parseInt("123")); // parseInt()

// 3. Autoboxing и unboxing
int value = 5;
Integer wrapped = value;      // autoboxing (автоматическое упаковывание)
int unwrapped = wrapped;      // unboxing (автоматическое распаковывание)

// 4. Null-safety для вычислений
Integer result = null;        // OK
int primitiveResult = null;   // ОШИБКА

Сравнение примитивов и ссылочных типов

┌──────────────────┬──────────────────┬──────────────────┐
│ Характеристика   │ Примитивы        │ Ссылочные типы  │
├──────────────────┼──────────────────┼──────────────────┤
│ Хранилище        │ Стек             │ Куча             │
│ Скорость         │ Очень быстро     │ Медленнее        │
│ Память           │ Фиксирована      │ Переменная       │
│ Передача         │ По значению      │ По ссылке        │
│ Null             │ Нельзя           │ Можно            │
│ Методы           │ Нельзя           │ Можно            │
│ Сравнение        │ ==               │ equals()         │
│ Пример           │ int, double      │ String, List     │
└──────────────────┴──────────────────┴──────────────────┘

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

Пример 1: Почему важна разница

public void demonstrateMemory() {
    // Примитивы быстрые
    long start = System.nanoTime();
    for (int i = 0; i < 10000000; i++) {
        int x = i * 2;  // операция на стеке
    }
    long primitiveDuration = System.nanoTime() - start;
    
    // Ссылочные типы медленнее
    start = System.nanoTime();
    for (int i = 0; i < 10000000; i++) {
        Integer x = i * 2;  // создание объектов на куче
    }
    long referenceDuration = System.nanoTime() - start;
    
    System.out.println("Примитив: " + primitiveDuration);
    System.out.println("Ссылка: " + referenceDuration);
    // Ссылочный тип обычно медленнее в 5-10 раз
}

Пример 2: Когда использовать

// Много вычислений → используй примитивы
public long calculateSum(int[] numbers) {
    long sum = 0;  // примитив для скорости
    for (int num : numbers) {
        sum += num;
    }
    return sum;
}

// Нужна гибкость и методы → используй ссылочные типы
public void processUsers(List<User> users) {  // List требует ссылочный тип
    for (User user : users) {
        String email = user.getEmail();  // String с методами
        System.out.println(email.toLowerCase());  // метод toLowerCase
    }
}

Выводы

Примитивы — для высокопроизводительных вычислений и большого объёма данных.

Ссылочные типы — для структурирования данных, использования методов и гибкости.

Правильный выбор типа данных — это основа эффективного Java кода.