Какие знаешь операции с Map?

Основные операции с коллекцией Map в Java/Kotlin для Android

Map (словарь или ассоциативный массив) — одна из фундаментальных коллекций, которую я ежедневно использую в Android-разработке. Операции с Map можно разделить на несколько категорий:

Базовые операции CRUD

Создание и инициализация:

// Kotlin
val mutableMap = mutableMapOf("key1" to 1, "key2" to 2)
val immutableMap = mapOf("key1" to 1) // read-only
val hashMap = HashMap<String, Int>()
val linkedMap = LinkedHashMap<String, Int>() // сохраняет порядок добавления

// Java
Map<String, Integer> map = new HashMap<>();
Map<String, Integer> linkedMap = new LinkedHashMap<>();

Добавление и обновление элементов:

// Kotlin
map["key"] = value          // оператор индексации
map.put("key", value)       // классический метод
map.putAll(anotherMap)      // добавление всех элементов другой карты
map.getOrPut("key") { defaultValue } // добавляет, если ключа нет

// Java
map.put("key", value);
map.putAll(anotherMap);

Получение значений:

val value = map["key"]              // возвращает nullable
val value = map.getValue("key")     // бросает исключение при отсутствии
val value = map.getOrDefault("key", defaultValue)
val value = map.getOrElse("key") { defaultValue }

Удаление элементов:

map.remove("key")                     // удаление по ключу
map.remove("key", expectedValue)      // удаление только если значение совпадает
map.clear()                           // полная очистка

Проверки и информация

val isEmpty = map.isEmpty()
val size = map.size
val containsKey = map.containsKey("key")
val containsValue = map.containsValue(value)

Итерация по элементам

// Kotlin
for ((key, value) in map) {
    println("$key -> $value")
}

map.forEach { (key, value) ->
    println("$key -> $value")
}

map.keys.forEach { key -> }
map.values.forEach { value -> }
map.entries.forEach { entry -> }

// Java
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
}

Трансформации и фильтрация (особенно в Kotlin)

Фильтрация:

val filtered = map.filter { (key, value) -> value > 10 }
val filteredByKey = map.filterKeys { it.startsWith("prefix") }
val filteredByValue = map.filterValues { it > 0 }

Трансформация:

val transformed = map.map { (key, value) -> key to value * 2 }.toMap()
val mappedValues = map.mapValues { (_, value) -> value * 2 }
val mappedKeys = map.mapKeys { (key, _) -> key.uppercase() }

Специфичные операции Kotlin

// Работа с nullable
val value = map["key"] ?: defaultValue

// Плюс-минус операции
val newMap = map + ("newKey" to value)    // иммутабельное добавление
val smallerMap = map - "keyToRemove"      // иммутабельное удаление

// Группировка
val grouped = list.groupBy { it.property } // создает Map<K, List<V>>

Потоковые операции (Java Stream API)

// Java
Map<String, Integer> filtered = map.entrySet().stream()
    .filter(entry -> entry.getValue() > 10)
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue
    ));

Android-специфичные аспекты

В Android-разработке я часто использую Map для:

1. Хранения конфигураций и параметров (с последующей передачей между компонентами)
2. Кэширования данных (LRU-кэш через LruCache, который реализует Map-интерфейс)
3. Работы с Bundle (сериализация/десериализация данных)
4. Аргументов Fragment/Activity (через arguments Bundle)

Важный нюанс для Android: при использовании Map в межпоточном контексте нужно помнить о потокобезопасности. HashMap не является потокобезопасным, поэтому в многопоточных сценариях я использую:

• ConcurrentHashMap для Java
• asSynchronized() в Kotlin или корутины с мьютексами
• Потокобезопасные коллекции из java.util.concurrent

Производительность и выбор реализации

• HashMap — O(1) для основных операций, не сохраняет порядок
• LinkedHashMap — сохраняет порядок вставки, немного медленнее HashMap
• TreeMap — O(log n), отсортированный по ключам
• ConcurrentHashMap — потокобезопасный, высокая производительность при конкурентном доступе

В Android-разработке правильный выбор реализации Map напрямую влияет на производительность приложения, особенно при работе с большими объемами данных или в UI-потоке, где важна минимальная блокировка.