Где используется Wrapper?

Где используется Wrapper

Wrapper (обёртка) в Java — это класс, который инкапсулирует примитивный тип в объект. Это один из основных паттернов Java, необходимый для работы с коллекциями и современными возможностями языка.

Что такое Wrapper?

Wrappers — это классы, которые "оборачивают" примитивные типы:

// Примитивные типы
int, long, float, double, boolean, byte, char, short

// Соответствующие Wrapper классы
Integer, Long, Float, Double, Boolean, Byte, Character, Short

Почему нужны Wrappers?

Примитивные типы не являются объектами, поэтому они не могут:

• Храниться в коллекциях (List, Set, Map)
• Быть null
• Использоваться как generic типы
• Иметь методы

// ERROR: примитивный тип не может быть в коллекции
List<int> list = new ArrayList<>();  // Ошибка компиляции!

// OK: используем Wrapper
List<Integer> list = new ArrayList<>();
list.add(10);  // Автоматически оборачивается

1. Использование в коллекциях

Хранение примитивных значений:

public class CollectionExample {
    
    public static void main(String[] args) {
        // List не может хранить примитивы напрямую
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        
        // Map также требует Wrapper
        Map<String, Double> prices = new HashMap<>();
        prices.put("apple", 1.5);
        prices.put("banana", 0.8);
        
        Set<Boolean> flags = new HashSet<>();
        flags.add(true);
        flags.add(false);
    }
}

2. Autoboxing и Unboxing

Autoboxing — автоматическое преобразование примитива в Wrapper:

public class AutoboxingExample {
    
    public static void main(String[] args) {
        // Autoboxing: int → Integer
        Integer x = 10;  // Вместо: Integer x = new Integer(10);
        
        // Работает с коллекциями
        List<Integer> list = new ArrayList<>();
        list.add(5);        // Autoboxing: int → Integer
        list.add(10);       // Autoboxing: int → Integer
        
        // Unboxing: Integer → int
        int first = list.get(0);  // Integer → int
        
        // Арифметические операции с Wrapper
        Integer a = 10;
        Integer b = 20;
        int sum = a + b;  // Unboxing + сложение
    }
}

Важно: Autoboxing может скрывать проблемы

public class AutoboxingProblem {
    
    public static void main(String[] args) {
        Integer x = null;  // null возможен
        
        // NullPointerException!
        int y = x;  // Unboxing null
        
        // Правильно:
        if (x != null) {
            int y = x;  // Безопасно
        }
    }
}

3. Использование методов Wrapper

Методы для преобразования:

public class WrapperMethods {
    
    public static void main(String[] args) {
        // String → Integer
        Integer num = Integer.parseInt("42");  // int
        Integer obj = Integer.valueOf("42");   // Integer
        
        // Integer → String
        String str = Integer.toString(42);
        
        // Проверка диапазона
        int value = Integer.parseInt("999");
        if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
            System.out.println("Valid integer");
        }
        
        // Double преобразования
        Double d = Double.parseDouble("3.14");
        Float f = Float.parseFloat("2.71");
        
        // Boolean
        Boolean b = Boolean.parseBoolean("true");
        Boolean b2 = Boolean.valueOf("false");
        
        // Character операции
        char c = 'A';
        System.out.println(Character.isLetter(c));
        System.out.println(Character.isDigit(c));
        System.out.println(Character.toUpperCase('a'));
    }
}

4. Сравнение и операции

Integer методы для сравнения:

public class WrapperComparison {
    
    public static void main(String[] args) {
        Integer x = 10;
        Integer y = 20;
        
        // Сравнение
        int comparison = Integer.compare(x, y);  // -1 (x < y)
        int comparison2 = x.compareTo(y);        // -1
        
        // Min и Max
        Integer min = Integer.min(x, y);  // 10
        Integer max = Integer.max(x, y);  // 20
        
        // Проверка в диапазоне
        int value = 5;
        if (value >= 0 && value <= 100) {
            System.out.println("Valid");
        }
    }
}

5. Generic типы

Wrapper необходим для Generic:

public class GenericExample {
    
    // Параметр типа должен быть объектом, не примитивом
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
    
    public static void main(String[] args) {
        // OK: Integer (Wrapper)
        Integer[] numbers = {1, 2, 3};
        printArray(numbers);
        
        // ERROR: примитивный тип не допускается
        // int[] primitives = {1, 2, 3};
        // printArray(primitives);  // Ошибка компиляции
        
        // Generic класс
        Pair<Integer, String> pair = new Pair<>(10, "Hello");
    }
}

public class Pair<K, V> {
    private K key;
    private V value;
    
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

6. Null и Optional

Wrapper может быть null:

public class WrapperNull {
    
    public static void main(String[] args) {
        Integer x = null;  // Возможно
        
        // Проверка null
        if (x != null) {
            int y = x;  // Безопасно
        }
        
        // Лучше: используй Optional
        Optional<Integer> opt = Optional.of(10);
        int value = opt.orElse(0);  // Значение по умолчанию
    }
}

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

Подсчёт частоты элементов:

public class FrequencyCounter {
    
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "apple", "cherry", "apple");
        
        // Map<String, Integer> для подсчёта
        Map<String, Integer> frequency = new HashMap<>();
        
        for (String word : words) {
            // getOrDefault возвращает Integer или 0
            int count = frequency.getOrDefault(word, 0);
            frequency.put(word, count + 1);  // Autoboxing
        }
        
        frequency.forEach((word, count) -> {
            System.out.println(word + ": " + count);
        });
    }
}

Валидация данных:

public class DataValidator {
    
    public void processUserAge(String ageStr) {
        try {
            Integer age = Integer.valueOf(ageStr);  // String → Integer
            
            if (age != null && age >= 0 && age <= 150) {
                System.out.println("Valid age: " + age);
            } else {
                System.out.println("Invalid age range");
            }
        } catch (NumberFormatException e) {
            System.out.println("Invalid format");
        }
    }
}

Stream API:

public class StreamExample {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        
        // Требует Wrapper Integer
        int sum = numbers.stream()
            .filter(n -> n > 2)
            .map(n -> n * 2)
            .reduce(0, Integer::sum);
        
        System.out.println("Sum: " + sum);
    }
}

Таблица Wrapper классов

Best Practices

// ✅ Правильно:
List<Integer> list = new ArrayList<>();  // Для коллекции
Integer value = Integer.valueOf("42");   // Явное преобразование
int x = 10;                              // Примитив когда не нужна null

// ❌ Неправильно:
Integer x = null;
int y = x;  // NullPointerException!

// ✅ Правильно:
Integer x = null;
if (x != null) {
    int y = x;  // Безопасно
}

Итог

Wrapper используется для:

1. Коллекций — List, Set, Map требуют объектов
2. Generic типов — параметры типа не могут быть примитивами
3. Null значений — примитивы не могут быть null
4. Методов объектов — преобразование, сравнение, форматирование
5. Stream API и функционального программирования

Wrappers — это мост между примитивными типами (быстрыми) и объектной системой Java, позволяя использовать примитивы везде, где нужны объекты.