Как сделать Map из списка

Как сделать Map из списка

Преобразование списка в Map - частая операция в Java. Существует несколько способов в зависимости от требований.

1. Stream API с toMap() - современный подход

Самый удобный и читаемый способ:

import java.util.stream.Collectors;

// Простое преобразование
List<String> list = Arrays.asList("Java", "Python", "JavaScript");
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        String::length,      // ключ
        s -> s               // значение
    ));
// Результат: {4=Java, 6=Python, 10=JavaScript}

2. Использование объектов как ключей

class User {
    private Long id;
    private String name;
    
    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    
    // getters...
}

List<User> users = Arrays.asList(
    new User(1L, "Alice"),
    new User(2L, "Bob"),
    new User(3L, "Charlie")
);

// Map с ID в качестве ключа
Map<Long, User> userMap = users.stream()
    .collect(Collectors.toMap(
        User::getId,      // ключ
        user -> user      // значение (сам объект)
    ));

// Или с именем в качестве ключа
Map<String, User> usersByName = users.stream()
    .collect(Collectors.toMap(
        User::getName,    // ключ
        user -> user      // значение
    ));

3. Обработка дубликатов ключей

Если в списке могут быть элементы с одинаковыми ключами:

// ❌ Плохо - выбросит исключение при дубликате
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        String::length,
        s -> s
    )); // IllegalStateException если два слова одинаковой длины

// ✅ Хорошо - указать функцию слияния
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        String::length,           // ключ
        s -> s,                   // значение
        (existing, replacement) -> existing  // В случае дубликата берем старое
    ));

// Или берем новое значение
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        String::length,
        s -> s,
        (existing, replacement) -> replacement  // Берем новое
    ));

// Или объединяем
Map<Integer, String> map = list.stream()
    .collect(Collectors.toMap(
        String::length,
        s -> s,
        (existing, replacement) -> existing + ", " + replacement  // Объединяем
    ));

4. Создание Map с конкретным типом

// LinkedHashMap - сохраняет порядок insertion
Map<Long, User> userMap = users.stream()
    .collect(Collectors.toMap(
        User::getId,
        user -> user,
        (a, b) -> a,
        LinkedHashMap::new  // Конкретная реализация
    ));

// TreeMap - сортированный по ключам
Map<Long, User> sortedMap = users.stream()
    .collect(Collectors.toMap(
        User::getId,
        user -> user,
        (a, b) -> a,
        TreeMap::new
    ));

// ConcurrentHashMap - потокобезопасный
Map<Long, User> concurrentMap = users.stream()
    .collect(Collectors.toMap(
        User::getId,
        user -> user,
        (a, b) -> a,
        ConcurrentHashMap::new
    ));

5. groupingBy() - для группировки

Если нужно сгруппировать элементы по ключу:

// Группировка: длина строки -> список строк
Map<Integer, List<String>> grouped = list.stream()
    .collect(Collectors.groupingBy(String::length));
// Результат: {4=[Java], 6=[Python], 10=[JavaScript]}

// Группировка с преобразованием значений
Map<Integer, List<String>> grouped = list.stream()
    .collect(Collectors.groupingBy(
        String::length,
        Collectors.mapping(String::toUpperCase, Collectors.toList())
    ));
// Результат: {4=[JAVA], 6=[PYTHON], 10=[JAVASCRIPT]}

// Группировка с подсчетом
Map<Integer, Long> counts = list.stream()
    .collect(Collectors.groupingBy(
        String::length,
        Collectors.counting()
    ));
// Результат: {4=1, 6=1, 10=1}

6. Классический способ (без Stream)

List<String> list = Arrays.asList("Java", "Python");
Map<Integer, String> map = new HashMap<>();

for (String str : list) {
    map.put(str.length(), str);
}

// Или с putIfAbsent
for (String str : list) {
    map.putIfAbsent(str.length(), str);
}

// Или с computeIfAbsent
for (String str : list) {
    map.computeIfAbsent(str.length(), k -> str);
}

7. Правила для успешного преобразования

// ❌ Ошибка: null ключ
List<User> users = Arrays.asList(
    new User(null, "Alice")  // Problematic
);
Map<Long, User> map = users.stream()
    .collect(Collectors.toMap(User::getId, u -> u));
// NullPointerException!

// ✅ Решение: фильтруйте перед преобразованием
Map<Long, User> map = users.stream()
    .filter(u -> u.getId() != null)
    .collect(Collectors.toMap(User::getId, u -> u));

8. Пример со сложной логикой

class Product {
    private Long id;
    private String name;
    private String category;
    private double price;
    
    // getters...
}

List<Product> products = /*...*/;

// Map: категория -> список продуктов
Map<String, List<Product>> byCategory = products.stream()
    .collect(Collectors.groupingBy(Product::getCategory));

// Map: категория -> список имен продуктов
Map<String, List<String>> namesByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.mapping(Product::getName, Collectors.toList())
    ));

// Map: категория -> средняя цена
Map<String, Double> avgPriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.averagingDouble(Product::getPrice)
    ));

// Map: ID -> Product (с обработкой дубликатов)
Map<Long, Product> productMap = products.stream()
    .collect(Collectors.toMap(
        Product::getId,
        p -> p,
        (existing, newer) -> newer  // Берем новый продукт при конфликте
    ));

Сравнение методов

Вывод: используйте Stream API toMap() или groupingBy() для большинства случаев - это современный, читаемый и эффективный способ преобразования списков в Map.