Для чего нужны классы-обертки примитивных типов данных?

Классы-обертки примитивных типов (Wrapper Classes)

Классы-обертки (wrapper classes) — это объектные представления примитивных типов данных Java. Они позволяют работать с примитивными типами как с объектами и предоставляют полезные утилиты для их обработки.

Основные классы-обертки

Зачем нужны классы-обертки?

1. Работа с коллекциями

Коллекции (List, Set, Map) могут хранить только объекты, а не примитивные типы. Поэтому нужны обертки:

// Неправильно (не скомпилируется)
// List<int> numbers = new ArrayList<>();

// Правильно (с использованием обертки)
List<Integer> numbers = new ArrayList<>();
numbers.add(42);
numbers.add(100);

Set<Double> prices = new HashSet<>();
prices.add(19.99);
prices.add(29.99);

Map<String, Long> statistics = new HashMap<>();
statistics.put("views", 1000000L);
statistics.put("clicks", 50000L);

2. Null-безопасность и необязательные значения

Примитивные типы не могут быть null, а обертки могут:

// Примитивный тип
int age = null; // ОШИБКА компиляции!

// С обёрткой
Integer age = null; // OK, может быть null
Integer optionalAge = getUserAge(userId); // может быть null или значение

if (optionalAge != null) {
    System.out.println("Age: " + optionalAge);
}

// Или с Optional (модерный подход)
Optional<Integer> age = getUserAge(userId);
age.ifPresent(a -> System.out.println("Age: " + a));

3. Полезные методы и константы

Каждый класс-обертка содержит методы и константы для работы с типом:

// Integer
int parsed = Integer.parseInt("42");
String hexString = Integer.toHexString(255);
int maxValue = Integer.MAX_VALUE;  // 2147483647
int minValue = Integer.MIN_VALUE;  // -2147483648
int bits = Integer.bitCount(255);  // количество единиц в бинарном представлении

// Double
double absValue = Double.valueOf("-3.14").doubleValue();
boolean isNaN = Double.isNaN(Double.NaN);
boolean isInfinite = Double.isInfinite(Double.POSITIVE_INFINITY);

// Boolean
boolean value = Boolean.parseBoolean("true");
int compare = Boolean.compare(true, false);

// Character
boolean isDigit = Character.isDigit(5);
boolean isLetter = Character.isLetter(A);
char upper = Character.toUpperCase(a);

4. Преобразование типов

Обертки предоставляют методы для парсинга и преобразования строк:

// Парсинг из строк
Integer age = Integer.valueOf("25");
Long timeout = Long.parseLong("5000");
Double price = Double.parseDouble("99.99");
Boolean isActive = Boolean.parseBoolean("true");

// Преобразование в строку
String intStr = Integer.toString(42);
String longStr = Long.toHexString(255L);
String binStr = Integer.toBinaryString(10);

// Обработка исключений
try {
    Integer num = Integer.valueOf("not a number");
} catch (NumberFormatException e) {
    System.out.println("Invalid number format");
}

5. Сравнение и хеширование

Обертки корректно реализуют equals() и hashCode(), что важно для коллекций:

Integer a = 100;
Integer b = 100;
Integer c = new Integer(100);

System.out.println(a == b);  // true (кеширование значений -128 до 127)
System.out.println(a.equals(b));  // true (правильное сравнение)
System.out.println(a.equals(c));  // true

// Использование в Set
Set<Integer> numbers = new HashSet<>();
numbers.add(100);
numbers.add(100);
System.out.println(numbers.size());  // 1 (дубликаты не добавляются)

Autoboxing и Unboxing

Java автоматически преобразует примитивные типы в обертки и наоборот (с Java 5):

// Autoboxing (примитив -> объект)
Integer num = 42;  // автоматически Integer.valueOf(42)
List<Integer> list = new ArrayList<>();
list.add(100);  // автоматический autoboxing

// Unboxing (объект -> примитив)
int value = num;  // автоматически num.intValue()
int sum = list.get(0) + 50;  // автоматический unboxing

// Может привести к NullPointerException при unboxing
Integer nullNum = null;
int result = nullNum + 10;  // Выбросит NullPointerException!

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

Автоматическое кеширование для улучшения производительности:

Integer a = 100;
Integer b = 100;
Integer c = 1000;
Integer d = 1000;

System.out.println(a == b);  // true (кешированное значение)
System.out.println(c == d);  // false (значение вне кеша)
System.out.println(c.equals(d));  // true (используй equals для сравнения!)

// Диапазон кеширования: -128 до 127 для Integer
Integer x = Integer.valueOf(127);
Integer y = Integer.valueOf(127);
System.out.println(x == y);  // true

Integer x2 = Integer.valueOf(128);
Integer y2 = Integer.valueOf(128);
System.out.println(x2 == y2);  // false (новые объекты)

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

public class UserProfile {
    private String name;
    private Integer age;  // может быть null, если возраст неизвестен
    private Double height;  // может быть null, если значение не указано
    
    public UserProfile(String name, Integer age, Double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + (age != null ? age : "Not specified"));
        System.out.println("Height: " + (height != null ? height : "Not specified"));
    }
    
    public Integer getAgeGroup() {
        if (age == null) return null;
        
        if (age < 18) return 1;
        if (age < 65) return 2;
        return 3;
    }
}

Вывод

Классы-обертки необходимы для:

• Работы с коллекциями
• Обработки null значений
• Преобразования типов
• Использования методов утилит
• Соответствия ООП парадигме

Однако нужно помнить о производительности (autoboxing может быть затратным) и всегда использовать .equals() для сравнения обёрток вместо оператора ==.