Зачем нужно параметризовать коллекции?

# Параметризация коллекций (Generics): зачем это нужно?

Параметризация коллекций — одна из самых важных фишек в Java. Это обеспечивает type safety при работе с коллекциями и предотвращает множество ошибок.

Проблема без Generics

// ❌ Без Generics — опасно
List list = new ArrayList();
list.add("John");
list.add(42);
list.add(new Date());
list.add(null);

// Когда вытаскиваем — не знаем, что там
for (Object obj : list) {
    String name = (String) obj; // ClassCastException на числе!
    System.out.println(name.toUpperCase());
}

Проблемы:

• Runtime ClassCastException
• Нет type safety
• Ошибки проявляются только при выполнении
• Код сложно читать

Решение: параметризация

// ✅ С Generics — безопасно
List<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");
// names.add(42); // Ошибка компилятора! ✓
// names.add(null); // Лучше использовать Optional

for (String name : names) {
    System.out.println(name.toUpperCase()); // Безопасно
}

Преимущества:

• Compile-time type checking — ошибки ловим до запуска
• Нет нужды в кастировании — компилятор делает за нас
• Читаемость — ясно, что в коллекции
• Безопасность — ClassCastException не будет

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

1. Collections без параметризации

// ❌ Плохо
Map map = new HashMap();
map.put("age", 30);
map.put("name", "John");

for (Object key : map.keySet()) {
    Integer age = (Integer) map.get(key); // может упасть
}

// ✅ Хорошо
Map<String, Integer> ages = new HashMap<>();
ages.put("john", 30);
ages.put("jane", 28);

for (String name : ages.keySet()) {
    Integer age = ages.get(name); // безопасно
}

2. Методы с параметризованными типами

public class UserRepository {
    
    // ❌ Без параметризации
    public List findAll() {
        return new ArrayList();
    }
    
    // ✅ С параметризацией
    public List<User> findAll() {
        return new ArrayList<>();
    }
    
    public Optional<User> findById(UUID id) {
        // Явно показываем, что может быть либо User, либо пусто
        return Optional.empty();
    }
}

3. Собственные параметризованные классы

// Общее решение для любого типа
public class Container<T> {
    private T value;
    
    public void set(T value) {
        this.value = value;
    }
    
    public T get() {
        return value;
    }
}

// Использование
Container<String> stringContainer = new Container<>();
stringContainer.set("Hello");
String value = stringContainer.get(); // безопасно

Container<Integer> intContainer = new Container<>();
intContainer.set(42);
Integer number = intContainer.get(); // безопасно

4. Параметризованные методы

public class GenericUtils {
    
    // Метод работает с любым типом
    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
    
    // Более сложный пример
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list.isEmpty()) {
            throw new IllegalArgumentException("List is empty");
        }
        
        T max = list.get(0);
        for (T element : list) {
            if (element.compareTo(max) > 0) {
                max = element;
            }
        }
        return max;
    }
}

// Использование
List<Integer> numbers = List.of(5, 2, 8, 1);
Integer maxNumber = GenericUtils.findMax(numbers); // Работает!

List<String> words = List.of("apple", "banana", "cherry");
String maxWord = GenericUtils.findMax(words); // Работает!

Wildcards

1. Unbounded wildcards (?)

public void printList(List<?> list) {
    for (Object element : list) {
        System.out.println(element);
    }
}

// Работает с List<String>, List<Integer>, List<Any>
printList(List.of("a", "b"));
printList(List.of(1, 2, 3));

2. Upper bounded wildcards (? extends)

// Работает только с Number и его подклассами
public double sum(List<? extends Number> numbers) {
    double total = 0;
    for (Number num : numbers) {
        total += num.doubleValue();
    }
    return total;
}

sum(List.of(1, 2, 3)); // Integer extends Number
sum(List.of(1.5, 2.7, 3.1)); // Double extends Number
// sum(List.of("a", "b")); // Ошибка! String не extends Number

3. Lower bounded wildcards (? super)

public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

List<Object> objects = new ArrayList<>();
addNumbers(objects); // Работает, Integer super Integer ✓

List<Integer> integers = new ArrayList<>();
addNumbers(integers); // Работает

List<String> strings = new ArrayList<>();
// addNumbers(strings); // Ошибка!

PECS правило (Producer Extends, Consumer Super)

public class Collections {
    
    // Если метод ЧИТАЕТ из коллекции (producer) — используй extends
    public static <T> void copy(
            List<? super T> dest,
            List<? extends T> src) {
        for (T element : src) {
            dest.add(element);
        }
    }
}

// Использование
List<Object> objects = new ArrayList<>();
List<String> strings = List.of("a", "b");
Collections.copy(objects, strings); // Perfect!

Реальные примеры из Spring

// Spring Repository
public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    List<T> findAll();
    void save(T entity);
}

// Spring Application Context
public interface ApplicationContext {
    <T> T getBean(Class<T> requiredType);
    Map<String, Object> getBeansOfType(Class<?> type);
}

// Spring Data Query
List<T> findByNameContaining(String name);

Type Erasure

⚠️ Важно знать про ограничение:

public class Box<T> {
    private T value;
    
    // ❌ Нельзя
    // public void add(T element) {
    //     if (element instanceof T) { // Compile error!
    //     }
    // }
    
    // ✅ Решение: используй Class
    public void add(T element, Class<T> type) {
        if (type.isInstance(element)) { // Работает
        }
    }
}

Причина: Generics работают только на этапе компиляции. Runtime информация о типе стирается (type erasure).

Практические рекомендации

1. Всегда параметризуй коллекции

// ❌ Не делай так
List list = new ArrayList();
Map map = new HashMap();
Set set = new HashSet();

// ✅ Делай так
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Set<UUID> set = new HashSet<>();

2. Используй Diamond operator

// ❌ Старый стиль (Java 6)
List<String> list = new ArrayList<String>();

// ✅ Новый стиль (Java 7+)
List<String> list = new ArrayList<>();

3. Предпочитай конкретные типы

// ❌ Слишком общее
public void process(List list) { }

// ✅ Конкретно
public void process(List<User> users) { }

Заключение

Параметризация коллекций — это:

• Type safety — ошибки на этапе компиляции
• Code clarity — явно видно, что в коллекции
• Less casting — компилятор делает за нас
• Better IDE support — автодополнение работает
• Performance — нет ненужных кастирований

Это базовый инструмент modern Java. Если видишь непараметризованные коллекции — это красный флаг, указывающий на старый или некачественный код.