HashMap<K, V>抽象 最终

基于哈希表的 Map 实现。

HashMap 是无序的(迭代顺序不保证)。

HashMap 中的键必须有一致的 Object.==Object.hashCode 实现。这意味着 == 运算符必须在键上定义一个稳定的等价关系(自反性、对称性、传递性和随时间保持一致),并且对于通过 == 被视为等价的对象,hashCode 必须相同。

遍历映射的键、值或条目(通过 forEach)可能是任意顺序。迭代顺序只有在修改映射时才会改变。值是以与它们相关联的键相同的顺序迭代的,因此平行遍历 keysvalues 将给出匹配的键和值对。

注意:在进行操作(例如在调用 forEachputIfAbsent 期间调用的函数)或在迭代映射(keysvaluesentries)时,不要修改映射(添加或删除键),可能会引发错误。

在键在映射中时,不要以任何方式修改它们,以改变它们的等价性(从而改变它们的哈希码)。如果一个映射键的 Object.hashCode 发生变化,可能会导致未来对该键的查找失败。

示例

final Map<int, String> planets = HashMap(); // Is a HashMap

要将数据添加到映射中,请使用 operator[]addAlladdEntries

planets[3] = 'Earth';
planets.addAll({4: 'Mars'});
final gasGiants = {6: 'Jupiter', 5: 'Saturn'};
planets.addEntries(gasGiants.entries);
print(planets); // fx {5: Saturn, 6: Jupiter, 3: Earth, 4: Mars}

要检查映射是否为空,请使用 isEmptyisNotEmpty。要查找映射条目的数量,请使用 length

final isEmpty = planets.isEmpty; // false
final length = planets.length; // 4

forEach 遍历映射的所有条目。

planets.forEach((key, value) {
  print('$key \t $value');
  // 5        Saturn
  // 4        Mars
  // 3        Earth
  // 6        Jupiter
});

要检查映射是否具有特定键的条目,请使用 containsKey

final keyOneExists = planets.containsKey(4); // true
final keyFiveExists = planets.containsKey(1); // false

要检查映射是否具有特定值的条目,请使用 containsValue

final marsExists = planets.containsValue('Mars'); // true
final venusExists = planets.containsValue('Venus'); // false

要删除具有特定键的条目,请使用 remove

final removeValue = planets.remove(5);
print(removeValue); // Jupiter
print(planets); // fx {4: Mars, 3: Earth, 5: Saturn}

要根据它们的键和值同时删除多个条目,请使用 removeWhere

planets.removeWhere((key, value) => key == 5);
print(planets); // fx {3: Earth, 4: Mars}

根据是否已存在具有该键的条目,有条件地添加或修改特定键的值,请使用 putIfAbsentupdate

planets.update(4, (v) => 'Saturn');
planets.update(8, (v) => '', ifAbsent: () => 'Neptune');
planets.putIfAbsent(4, () => 'Another Saturn');
print(planets); // fx {4: Saturn, 8: Neptune, 3: Earth}

根据现有的键和值更新所有键的值,请使用 updateAll

planets.updateAll((key, value) => 'X');
print(planets); // fx {8: X, 3: X, 4: X}

要删除所有条目并清空映射,请使用 clear

planets.clear();
print(planets); // {}
print(planets.isEmpty); // true

另请参阅

实现类型

构造函数

HashMap({bool equals(K, K)?, int hashCode(K)?, bool isValidKey(dynamic)?})
创建一个基于非顺序哈希表 Map
工厂
HashMap.from(Map other)
创建一个包含所有键值对的 HashMap,这些键值对均来自 other
工厂
HashMap.fromEntries(Iterable<MapEntry<K, V>> entries)
创建一个包含 entries 中的条目的 HashMap
工厂
HashMap.fromIterable(Iterable iterable, {K key(dynamic element)?, V value(dynamic element)?})
创建一个 HashMap,其键和值由 iterable 计算得出。
工厂
HashMap.fromIterables(Iterable<K> keys, Iterable<V> values)
创建一个将给定 keys 关联到 valuesHashMap
工厂
HashMap.identity()
创建一个基于身份的非顺序映射。
工厂
HashMap.of(Map<K, V> other)
创建一个包含所有键值对的 HashMap,这些键值对均来自 other。示例
工厂

属性

entries Iterable<MapEntry<K, V>>
映射的条目。
没有setter,继承自
hashCode int
此对象的哈希码。
没有setter,继承自
isEmpty bool
判断map中是否没有键/值对。
没有setter,继承自
isNotEmpty bool
判断map中是否至少有一个键/值对。
没有setter,继承自
keys Iterable<K>
本map的键。
没有setter,继承自
length int
map中键/值对的数量。
没有setter,继承自
runtimeType Type
对象运行时类型的表示。
没有setter,继承自
values Iterable<V>
本map的值。
没有setter,继承自

方法

addAll(Map<K, V> other) → void
other中的所有键/值对添加到本map中。
继承
addEntries(Iterable<MapEntry<K, V>> newEntries) → void
newEntries中的所有键/值对添加到本map中。
继承
cast<RK, RV>() Map<RK, RV>
提供一种视图,如果需要的话,将此map视为具有RK键和RV实例。
继承
clear() → void
从map中删除所有条目。
继承
containsKey(Object? key) bool
此map是否包含指定的key
继承
containsValue(Object? value) bool
此map是否包含指定的value
继承
forEach(void action(K key, V value)) → void
action应用于map中的每个键/值对。
继承
map<K2, V2>(MapEntry<K2, V2> convert(K key, V value)) Map<K2, V2>
返回一个新映射,其中此映射的所有条目都通过给定的 convert 函数转换。
继承
noSuchMethod(Invocation invocation) → dynamic
当访问不存在的方法或属性时调用。
继承
putIfAbsent(K key, V ifAbsent()) → V
查找 key 的值,如果不存在,则添加一个新的条目。
继承
remove(Object? key) → V?
如果存在,则从映射中删除 key 和其关联的值。
继承
removeWhere(bool test(K key, V value)) → void
删除此映射所有满足给定 test 的条目。
继承
toString() String
此对象的字符串表示。
继承
update(K key, V update(V value), {V ifAbsent()?}) → V
更新提供的 key 的值。
继承
updateAll(V update(K key, V value)) → void
更新所有值。
继承

操作符

operator ==(Object other) bool
等于操作符。
继承
operator [](Object? key) → V?
给定 key 的值,如果 key 不在映射中,则返回 null
继承
operator []=(K key, V value) → void
将给定的 valuekey 关联。
继承