前言
List、Set和Map有一些通用的方法。其中的一些通用方法都是来自于类Iterable。List和Set是iterable类的实现。 虽然Map没有实现Iterable, 但是Map的属性keys和values都是Iterable对象。
通用方法如下：
var testSet = Set.from(["a", "b", "c"]);
var testList = [1, 2, 3, 4];
var testMap = Map();
iterable提供了 map 方法，来处理每一个集合中的对象，并返回一个结果
var setIter = testSet.map((v) => v.toUpperCase());
print(setIter); // (A, B, C)
iterable提供了where方法，来过滤集合中的值，并返回一个集合
var whereList = testList.where((num) => num > 2).toList();
print(whereList); // [3, 4]。如果不用toList()则返回(3, 4)
iterable提供了any方法和every方法，来判断集合中的值是否符合条件，并返回bool
print(testList.any((num) => num > 2)); // true
特定方法如下：
Map.from(Map other)
入参other映射本身可以是任何值，与Map.of不同的是k，v在运行时会检查（可能失败），创建一个把无序map转换成按键值对插入
final planets = <num, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth', 4: 'Mars'};
final mapFrom = Map<int, String>.from(planets);
print(mapFrom); // {1: Mercury, 2: Venus, 3: Earth, 4: Mars}
如果碰到
Unhandled Exception: type '_InternalLinkedHashMap<dynamic, dynamic>' is not a subtype of type 'Map<String, dynamic>'
那么只需要将Map<String, dynamic>.from(data)做一下转换处理即可
Map.of(Map other)
创建与other相同k，v的linkedHashMap，允许key是null
final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth'};
final mapOf = Map<num, String>.of(planets);
print(mapOf); // {1: Mercury, 2: Venus, 3: Earth}
Map.unmodifiable
创建一个不可变的map，保留ohter的顺序，生成结果类似Map.from，只是返回的不可修改
final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth'};
final unmodifiableMap = Map.unmodifiable(planets);
unmodifiableMap[4] = 'Mars'; // Throws
Map.fromIterable
根据提供的list按照条件创建map
final numbers = <int>[1, 2, 3];
final map = Map<String, int>.fromIterable(numbers,
key: (item) => item.toString(),
value: (item) => item * item);
print(map); // {1: 1, 2: 4, 3: 9}
相同的
List<int> list = [1, 2, 3];
Map<String, int> map = { for (var item in list) item.toString() : item * item };
map['1'] + map['2']; // 1 + 4
map['3'] - map['2']; // 9 - 4
也可以不根据条件创建map
final numbers = <int>[1, 2, 3];
final map = Map.fromIterable(numbers);
print(map); // {1: 1, 2: 2, 3: 3}
Map.fromIterables
整合2个list，将指定的keys关联到values上
final rings = <bool>[false, false, true, true];
final planets = <String>{'Earth', 'Mars', 'Jupiter', 'Saturn'};
final map = Map<String, bool>.fromIterables(planets, rings);
print(map); // {Earth: false, Mars: false, Jupiter: true, Saturn: true}
Map<K2, V2> castFrom
按照map初始化出一个新的mapNew，并且强制类型一致
Map map = {'a':'A','b':'B','c':'C'};
Map mapNew = Map.castFrom(map); /// {'a':'A','b':'B','c':'C'}
update() 对指定的key的value做出修改
如果存在则返回修改后的值。如果不存在则报错，若不想报错加ifAbsend函数，则会返回ifAbsend函数的值并且添加到map中
Map<String,int> map23 = {"a":1,"b":2,"c":3};
int result3 = map23.update("a", (value)=>(value*2));//key存在 根据参数函数修改其值
print(result3);//2
print(map23);//{a: 2, b: 2, c: 3}
int result4 = map23.update("d", (value)=>(value*2));//key不存在 报错
int result4 = map23.update("d", (value)=>(value*2),ifAbsent: ()=>(10));//key不存在 但有ifAbsent参数 返回ifAbsent函数的值 并添加到map中
print(result4);//10
print(map23);//{a: 2, b: 2, c: 3, d: 10}
updateAll() 根据参数函数的规则，批量修改map
Map<String,int> map24 = {"a":1,"b":2,"c":3};
map24.updateAll((String key,int value){
return value*2;
});//
print(map24);//{a: 2, b: 4, c: 6}
Map<String,int> map25 = {"a":1,"b":2,"c":3};
map25.updateAll((String key,int value){
if(key=="a"){return 10;}
if(key=="b"){return 20;}
return value*2;
});//
print(map25);//{a: 10, b: 20, c: 6}
remove() 删除一个key
如果不存在key，则无事发生
Map<String,int> map9 = {"a":1,"b":2,"c":3,"d":4,"e":5};
map9.remove("b");
print(map9);//{a: 11, c: 3, d: 4, e: 5}
map9.remove("f");
print(map9);//{a: 11, c: 3, d: 4, e: 5}
removeWhere() 根据条件批量删除
Map<String,int> map10 = {"a":1,"b":2,"c":3,"d":4,"e":5};
map10.removeWhere((key,value)=>(value>3));//删除掉 符合参数函数的keyvalue对
print(map10);//{a: 1, b: 2, c: 3}
遍历时，新增或删除key 都会报错，但是可以修改值
Map<String,int> map14 = {"a":1,"b":2,"c":3};
map14.forEach((String key,int value){
print("$key $value");
map14["d"] = 4;// 报错
map14.remove("a");// 报错
});
map() 遍历每个元素 根据参数函数，对keyvalue做出修改，可转换成其他泛型的Map
Map<String,int> map19 = {"a":1,"b":2,"c":3};
Map<int,String> map20 = map19.map((String key,int value){
return new MapEntry(value, key);
});
print(map20);//{1: a, 2: b, 3: c}
addAll() 整体合并另一个map 泛型要一致
Map<String,int> map16 = {"a":1,"b":2,"c":3};
Map<String,int> other = {"a":1,"c":4,"d":7};
Map<String,int> another = {"a":1,"c":4,"e":7};
map16.addAll(other);//key相同时value值后者覆盖前者，前者不存在时则添加进来
print(map16);//{a: 1, b: 2, c: 4, d: 7}
也可以通过.. 或者 ...的方式
var a = another..addAll(map16)..addAll(other);
或者
var a = {
...map16,
...other,
...another,
};
addEntries() 合并两个map 如果key有重复，被合并的map的value覆盖前者
Map<String,int> map26 = {"a":1,"b":2,"c":3};
Map<String,int> map27 = {"a":1,"b":4,"d":3,"e":5};
map26.addEntries(map27.entries);
print(map26);//{a: 1, b: 4, c: 3, d: 3, e: 5}
putIfAbsent() 存在key就获取值，不存在则添加到map 然后返回值
Map<String,int> map18 = {"a":1,"b":2,"c":3};
int result = map18.putIfAbsent("a", ()=>(2));//存在
print(result);//1 获取key的值
print(map18);//{a: 1, b: 2, c: 3} map不变
int result2 = map18.putIfAbsent("d", ()=>(2));//不存在
print(result2);//2 获取新的key的value
print(map18);//{a: 1, b: 2, c: 3, d: 2} map改变
