您可以使用此函数移除Map中的项目并自动生成新密钥：

Map<int, T> removeFromMap<T>(Map<int, T> map, int index) {
    var list = map.entries.map((e) => e.value).toList();
    list.removeAt(index);
    var newIndex = 1;

    return Map.fromIterable(list,
        key: (item) => newIndex++, value: (item) => item);
  }

您可以这样使用它：

var result = removeFromMap<String>({1: 'c', 2: 'dart', 3: 'flutter'}, 1);
print("result = $result"); //result = {1: c, 2: flutter}

如果要添加新项目：

Map<int, T> addToMap<T>(Map<int, T> map, T newItem) {
    var list = map.entries.map((e) => e.value).toList();
    list.add(newItem);
    var newIndex = 1;

    return Map.fromIterable(list,
        key: (item) => newIndex++, value: (item) => item);
  }

这样命名它：

var result = addToMap<String>({1: 'c', 2: 'dart', 3: 'flutter'}, 'B');
print("result = $result"); //result = {1: c, 2: dart, 3: flutter, 4: B}

你可以使用一个递增的index键，它在每次调用时总是与其他键不同，并将它 Package 在一个autoKey()方法中，如下所示：

int index = 0;
autoKey() {
  return ++index;
}

Map<int, String> map = {};
map = {autoKey(): 'c', autoKey(): 'dart', autoKey(): 'flutter'};

print(map); {1: c, 2: dart, 3: flutter}

也许我应该使用一个函数：

int getNewKey(Map map) {
  if (map.isEmpty) {
    return 0; // or 1, this is the first item I insert
  } else {
    return map.keys.last + 1;
  }
}

并在我向Map添加内容时使用它：
{getNewKey（Map）：'c'，getNewKey（Map）：' dart '，getNewKey（Map）：“ Flutter ”}
请让我知道这是错误的：-|
通过这种方式，我永远不会覆盖一个密钥，只有增量。
请注意：我不应该直接使用

{(map.keys.last + 1) : 'c', (map.keys.last + 1) : 'dart', (map.keys.last + 1) : 'flutter'}

因为如果Map为空会产生错误。

如果您有一个使用连续的、基于整数的密钥的Map，您应该问问自己是否应该使用List，这样您就不需要自己管理密钥了。
如果由于某些API需要而必须使用Map，您仍然可以从List开始，然后使用List.asMap轻松地转换它：

var map = [
    'c',
    'dart',
    'flutter',
  ].asMap();

print(map); // Prints: {0: c, 1: dart, 2: flutter}

请注意，List.asMap返回一个 unmodifable 视图，因此如果希望允许变异，则需要创建一个副本：

var map = Map.of([
    'c',
    'dart',
    'flutter',
  ].asMap());

如果必须让您的Map键是从1开始的整数，而不是0，则您可以插入一个伪元素（如果需要，稍后再移除它）：

var map = Map.of([
    '',
    'c',
    'dart',
    'flutter',
  ].asMap())
    ..remove(0);

print(map); // Prints: {1: c, 2: dart, 3: flutter}

另一种方法是使用class作为密钥，而使用hashCode则永远不等于其自身，如下所示：

class nonEqualKey {
  
  @override
  int get hashCode => 0;
  
  @override
  operator ==(covariant nonEqualKey other) {
    return other.hashCode != hashCode;
  }
  @override
  toString() {
    return "unique";
  }
}

Map map = {};
map = {nonEqualKey(): 'c', nonEqualKey(): 'dart', nonEqualKey(): 'flutter'};
print(map); // {unique: c, unique: dart, unique: flutter}

这里我重写了hashCode，所以它总是0，然后我重写了==运算符，所以如果对象有不同的hashCode，它们可以相等，这是不可能的，因为0!=0总是false。
即使您使用相同的class构造函数，它们也永远不会相同，因此，它允许您根据需要使用它，而无需为在Map上执行的每个操作处理它