Какими могут быть ключи в hash map?

Ключи в HashMap в Dart/Flutter

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

Основные требования к ключам

Любой ключ в HashMap должен удовлетворять двум требованиям:

1. Иметь стабильный hashCode — код не должен меняться во время жизни объекта
2. Реализовать оператор == (equality) — для сравнения ключей

// Правильная реализация для использования в HashMap
class User {
  final int id;
  final String name;
  
  User(this.id, this.name);
  
  // Обязательно переопредели hashCode и ==
  @override
  int get hashCode => id.hashCode ^ name.hashCode;
  
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) return true;
    return other is User && other.id == id && other.name == name;
  }
}

// Теперь можно использовать как ключ
final userMap = <User, String>{};
const user1 = User(1, 'Alice');
const user2 = User(1, 'Alice');

userMap[user1] = 'developer';
print(userMap[user2]);  // 'developer' — работает!

Встроенные типы (самые частые)

1. String — наиболее часто используемый

// String идеально подходит для HashMap
const config = <String, dynamic>{
  'apiUrl': 'https://api.example.com',
  'timeout': 30,
  'retryCount': 3,
  'enableLogging': true,
};

print(config['apiUrl']);  // 'https://api.example.com'
config['newKey'] = 'newValue';  // Добавление новых

// String имеет хороший hashCode
print('hello'.hashCode);  // Стабильный код
print('hello'.hashCode);  // Тот же код

Преимущества String как ключа:

• Стабилен (immutable)
• Понятен для разработчиков
• Легко сериализовать в JSON

2. int (целые числа)

// int часто используется для ID
final userDatabase = <int, Map<String, dynamic>>{
  1: {'name': 'Alice', 'age': 30},
  2: {'name': 'Bob', 'age': 25},
  3: {'name': 'Charlie', 'age': 35},
};

final user = userDatabase[2];  // Быстрый доступ по ID
print(user?['name']);  // 'Bob'

// int очень эффективен
print(42.hashCode);  // Быстро считается

3. bool (логические значения)

// bool как ключ для фичей или конфигов
final featureFlags = <bool, String>{
  true: 'enabled',
  false: 'disabled',
};

print(featureFlags[true]);   // 'enabled'
print(featureFlags[false]);  // 'disabled'

// Есть только два значения!
// Это редко встречается в real-world коде

4. double (числа с плавающей точкой)

// ⚠️ Осторожно с double!
final priceCache = <double, String>{};

priceCache[19.99] = 'expensive';
priceCache[19.99] = 'sale';

print(priceCache[19.99]);  // 'sale'

// Проблема: double может быть неточен
print(0.1 + 0.2 == 0.3);  // false!

// Лучше использовать String для цен
final priceCache2 = <String, String>{};
priceCache2['19.99'] = 'expensive';

⚠️ Внимание: double содержит погрешности вычислений, поэтому как ключ использовать не рекомендуется.

5. enum

// Enum идеален для HashMap ключей
enum UserRole { admin, moderator, user, guest }

const rolePermissions = <UserRole, List<String>>{
  UserRole.admin: ['read', 'write', 'delete', 'manage_users'],
  UserRole.moderator: ['read', 'write', 'delete'],
  UserRole.user: ['read', 'write'],
  UserRole.guest: ['read'],
};

final userRole = UserRole.user;
final permissions = rolePermissions[userRole];
print(permissions);  // ['read', 'write']

// Enum очень безопасен и эффективен
enum Status { pending, processing, completed, failed }

final statusMessages = <Status, String>{
  Status.pending: 'Ожидание...',
  Status.processing: 'Обработка...',
  Status.completed: 'Готово',
  Status.failed: 'Ошибка',
};

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

• Безопасность типов
• Невозможно создать недопустимое значение
• Эффективен в памяти
• Отлично для state management

Сложные типы (требуют осторожности)

1. List как ключ (редко и неправильно)

// ❌ НЕ делай так!
const listMap = <List<int>, String>{};
// List это mutable, hashCode меняется!

// Если всё же нужно:
final list1 = [1, 2, 3];
listMap[list1] = 'first';
list1.add(4);  // Меняем список
print(listMap[list1]);  // Может не найти!

// ✅ Лучше использовать Tuple или String
const coordinates = <String, String>{};
coordinates['1,2,3'] = 'point';

// Или использовать пакет tuple
import 'package:tuple/tuple.dart';
const tupleMap = <Tuple3<int, int, int>, String>{};

2. Кастомные классы

// ✅ Правильная реализация кастомного класса для HashMap
class Point {
  final int x;
  final int y;
  
  Point(this.x, this.y);
  
  @override
  int get hashCode => x.hashCode ^ y.hashCode;
  
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) return true;
    return other is Point && other.x == x && other.y == y;
  }
  
  @override
  String toString() => 'Point($x, $y)';
}

final grid = <Point, String>{};
grid[Point(0, 0)] = 'origin';
grid[Point(1, 1)] = 'diagonal';
grid[Point(5, 5)] = 'far';

print(grid[Point(0, 0)]);  // 'origin' — работает!

3. DateTime как ключ

// DateTime это immutable, можно использовать
final eventLog = <DateTime, String>{};

final now = DateTime.now();
eventLog[now] = 'App started';
eventLog[DateTime(2024, 3, 26)] = 'Special date';

print(eventLog[now]);  // 'App started'

// Но будь осторожен — DateTime содержит миллисекунды
final time1 = DateTime.now();
final time2 = DateTime.now();

print(time1 == time2);  // Обычно false (разные миллисекунды)

// Лучше использовать дату без времени
final dateLog = <DateTime, String>{};
final today = DateTime(2024, 3, 26);
dateLog[today] = 'Event';

Best Practices для HashMap ключей

// 1. Используй неизменяемые типы
// ✅ String, int, enum, DateTime
// ❌ List, Map, mutable классы

// 2. Правильная реализация hashCode и ==
class CacheKey {
  final String namespace;
  final int id;
  
  CacheKey(this.namespace, this.id);
  
  // Генерируется IDE
  @override
  int get hashCode => namespace.hashCode ^ id.hashCode;
  
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) return true;
    return other is CacheKey &&
        other.namespace == namespace &&
        other.id == id;
  }
}

// 3. Избегай использования changeable fields в hashCode
// ❌ Плохо
class BadKey {
  String value = 'initial';  // Может меняться!
  
  @override
  int get hashCode => value.hashCode;  // Ошибка!
}

// ✅ Хорошо
class GoodKey {
  final String value;  // final — не меняется
  
  GoodKey(this.value);
  
  @override
  int get hashCode => value.hashCode;
}

// 4. Используй equatable пакет для упрощения
import 'package:equatable/equatable.dart';

class UserKey extends Equatable {
  final int userId;
  final String tenantId;
  
  const UserKey(this.userId, this.tenantId);
  
  @override
  List<Object?> get props => [userId, tenantId];
}

// Автоматически генерирует hashCode и ==
final cache = <UserKey, User>{};
cache[UserKey(1, 'tenant_a')] = user;

Производительность различных типов

Резюме

Лучшие типы для HashMap ключей:

1. String — универсальный и понятный
2. int — для ID и чисел
3. enum — для конечного набора значений (best practice)
4. DateTime — для временных меток
5. Кастомные классы — только если реализуешь hashCode и == правильно

Избегай:

• List, Map и другие mutable типы
• double (из-за неточности)
• Классы с mutable полями в hashCode
• Слишком сложные иерархии наследования