Dart 中 List 数组的方法还是比较多的，这里我按照 CRUD 对这些方法进行分类汇总。其中 CRUD 指的是增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。

文章目录

  • 一："增加"数据的方法（4 个）
  • 二："删除"数据的方法（6 个）
  • 三："修改"数据的方法（5 个）
  • 四："查询"数据的方法（20 个）
  • 五："常用"的方法（12 个）

一："增加"数据的方法（4 个）

add 添加一个元素到数组末尾

List<String> l1 = ["周一", "周二", "周三"];
  l1.add("周四");
  l1.add("周五");
  print(l1); // [周一, 周二, 周三, 周四, 周五]

addAll 合并两个数组 

List<String> l1 = ["周一", "周二", "周三"];
  List<String> l2 = ["周四", "周五", "周六","周日"];
  l1.addAll(l2);
  print(l1); // [周一, 周二, 周三, 周四, 周五, 周六, 周日]

insert 在指定索引处插入一个值 

List<String> l1 = ["周一", "周二", "周三"];
  l1.insert(3, "周四");
  print(l1); // [周一, 周二, 周三, 周四]
  l1.insert(0, "周日");
  print(l1); // [周日, 周一, 周二, 周三, 周四]

insertAll 在指定索引处插入一个数组

List<String> l1 = ["周一", "周二", "周三"];
  List<String> l2 = ["周四", "周五", "周六", "周日"];
  l1.insertAll(0, l2);
  print(l1); // [周四, 周五, 周六, 周日, 周一, 周二, 周三]

二："删除"数据的方法（6 个）

remove 删除指定元素 

List<String> l1 = ["周一", "周二", "周三","周一"];
  l1.remove("周一");
  print(l1); // [周二, 周三, 周一]

removeAt 删除指定索引位置处的元素 

List<String> l1 = ["周一", "周二", "周三"];
  l1.removeAt(0);
  print(l1); // [周二, 周三]

removeLast 删除数组的最后一个元素 

List<String> l1 = ["周一", "周二", "周三"];
  l1.removeLast();
  print(l1); // [周一, 周二]

clear 清空数组 

List<String> l1 = ["周一", "周二", "周三"];
  l1.clear();
  print(l1); // []

removeWhere 根据指定条件删除元素 

List<String> l1 = ["周一", "周二", "周三"];
  l1.removeWhere((e) => e == "周二");
  print(l1); // [周一, 周三]
  
  List<String> l2 = ["周一", "周二", "周三","星期四"];
  l2.removeWhere((e) => e.contains("周"));
  print(l2); // [星期四]

关于以上删除元素的方法

  • 如果数组中有该数据或者满足删除的条件，则删除，原数组发生改动。
  • 如果要删除的数据不在数组中，或者删除元素的条件不成立，也不会报错，返回原数组。

removeRange 删除指定索引范围内的元素(含头不含尾)

List<String> l1 = ["周一", "周二", "周三","周四", "周五", "周六", "周日"];
  l1.removeRange(2, 5);
  print(l1); // [周一, 周二, 周六, 周日]

三："修改"数据的方法（5 个）

List [index] 修改指定索引位置元素的值

List<String> l1 = ["周一", "周二", "周三", "星期四"];
  l1[3] = "周四";
  print(l1); // [周一, 周二, 周三, 周四]

fillRange 用相同的值替换指定索引范围内的所有元素(含头不含尾)

List<String> l1 = ["周一", "周二", "周三", "周四", "周五"];
  l1.fillRange(1, 4, "AllenSu");
  print(l1); // [周一, AllenSu, AllenSu, AllenSu, 周五]

replaceRange 用某一数组替换指定索引范围内的所有元素(含头不含尾)

List<String> l1 = ["周一", "周二", "周三"];
  l1.replaceRange(1, 2, ["周四", "周五", "周六", "周日"]);
  print(l1); // [周一, 周四, 周五, 周六, 周日, 周三]
  
  List<String> l2 = ["周一", "周二", "周三", "周四", "周五"];
  l2.replaceRange(0, 4, ["周六", "周日"]);
  print(l2); // [周六, 周日, 周五]

setRange 范围替换数组中的值(含头不含尾)

List<String> l1 = ["11", "22", "33"];
  List<String> l2 = ["aa", "bb", "cc"];
  l1.setRange(0, 2, l2); // 用 l2 数组中索引为 0 1 位置处元素的值，替换掉 l1 数组中索引 0 1 位置处元素的值
  print(l1); // [aa, bb, 33]

setAll 从指定索引位置开始，使用第二个数组内的元素依次替换掉第一个数组中的元素

List<String> l1 = ["周一", "周二", "周三", "周四"];
  List<String> l2 = ["周五", "周六", "周日"];
  l1.setAll(1, l2);
  print(l1); // [周一, 周五, 周六, 周日]

注意: index + l2.length <= l1.length ,否则会报错。

四："查询"数据的方法（20 个）

elementAt 获取指定索引位置处的元素 

List<String> l1 = ["周一", "周二", "周三", "周四"];
  String str = l1.elementAt(2);
  print(str); // 周三

contains 判断数组中是否含有指定元素 

List<String> l1 = ["周一", "周二", "周三", "周四"];
  bool a = l1.contains("周一");
  bool b = l1.contains("周日");
  print(a); // true
  print(b); // false

indexOf 获取指定元素在数组中的索引 

List<String> l1 = ["周一", "周二", "周三", "周四", "周三"];
  int a = l1.indexOf("周三"); // 获取数组中第一次出现"周三"元素的索引
  int b = l1.indexOf("周三", 3); // 从索引为3开始，查找第一次出现"周三"元素的索引
  int c = l1.indexOf("周日");
  print(a); // 2
  print(b); // 4
  print(c); // -1，数组中不存在指定元素，返回 -1

lastIndexOf 从后向前查找指定元素在数组中的索引 

List<String> l1 = ["周一", "周二", "周三", "周四", "周三"];
  int a = l1.lastIndexOf("周三");
  int b = l1.lastIndexOf("周三", 3);
  int c = l1.lastIndexOf("周日");
  print(a); // 4
  print(b); // 2
  print(c); // -1

indexWhere 返回第一个满足条件的元素的索引

List<String> l1 = ["周一", "周二", "周三", "周四", "周三"];
  int a = l1.indexWhere((e) => e == "周三");
  print(a); // 2

lastIndexWhere 从后向前找，返回第一个满足条件的元素的索引

List<String> l1 = ["周一", "周二", "周三", "周四", "周三"];
  int a = l1.lastIndexWhere((e) => e == "周三");
  print(a); // 4

where 根据指定条件，函数筛选每个元素，符合条件的元素组成一个新的 Iterable 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.where((e) => e > 10);
  print(l2); // (12, 17, 33)
  
  List<int> l3 = l1.where((e) => e >= 10).toList();
  print(l3); // [12, 17, 33]

firstWhere 返回第一个满足条件的元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  int a = l1.firstWhere((e) => e > 10);
  print(a); // 12

lastWhere 从后向前查找第一个满足条件的元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  int a = l1.lastWhere((e) => e > 10);
  print(a); // 33

singleWhere 获取满足指定条件的唯一元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  int a = l1.singleWhere((e) => e > 30);
  int b = l1.singleWhere((e) => e > 33, orElse: () => -1);
  int c = l1.singleWhere((e) => e > 10, orElse: () => null);
  print(a); // 33
  print(b); // -1。数组中没有满足条件的元素，返回 orElse 方法指定的返回值(-1是自己填的，你也可以设置为其它值)
  print(c); // 报错。当数组中有多个满足条件的元素时，即使你设置了 orElse 的返回值，用 singleWhere 也会报错

retainWhere 保留满足条件的元素(改变了原数组) 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  l1.retainWhere((e) => e > 10);
  print(l1); // [12, 17, 33]

any 判断数组中是否有满足指定条件的元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  bool a = l1.any((e) => e > 30);
  print(a); // true

every 判断数组中是否每个元素都满足指定的条件

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  bool a = l1.every((e) => e > 1);
  print(a); // false

take 从索引 0 位置处，取指定个数的元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.take(3);
  print(l2); // (8, 12, 4)

takeWhile 从索引 0 位置处，查询满足指定条件的元素，直到出现第一个不符合条件的元素，然后返回前面符合条件的元素 

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.takeWhile((e) => e > 1);
  print(l2); // (8, 12, 4)

skip 跳过指定个数的元素，返回后面的元素

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.skip(4);
  print(l2); // (17, 33, 10)

skipWhile 根据指定条件，找到第一个不符合条件的元素，然后将该元素后面的所有元素返回

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.skipWhile((e) => e < 17);
  print(l2); // (17, 33, 10)

sublist 从指定索引处截取数组

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  List<int> l2 = l1.sublist(5);
  print(l2); // [33, 10]
  
  List<int> l3 = l1.sublist(2, 5);
  print(l3); // [4, 1, 17] 含头不含尾

getRange 截取指定索引范围内的元素

List<int> l1 = [8, 12, 4, 1, 17, 33, 10];
  Iterable<int> l2 = l1.getRange(2,5);
  print(l2); // (4, 1, 17)

whereType 从混合类型的数组中，筛选出指定类型的元素

List l1 = ["a", 15, "b", false, true, 20, "c",{"name":"AllenSu"}];
  Iterable<String> l2 = l1.whereType();
  Iterable<int> l3 = l1.whereType();
  Iterable<bool> l4 = l1.whereType();
  Iterable<Map> l5 = l1.whereType();
  print(l2); // (a, b, c)
  print(l3); // (15, 20)
  print(l4); // (false, true)
  print(l5); // ({name: AllenSu})

五："常用"的方法（12 个）

forEach 遍历数组中的元素

List<int> l1 = [8, 12, 4, 1];
  l1.forEach((e) => print(e)); // 8 12 4 1

map 遍历数组中的所有元素，可以对元素进行处理，并返回新的 Iterable

List<int> l1 = [8, 12, 4, 6, 22, 34, 10];
  Iterable<bool> l2 = l1.map((e) => e > 10);
  Iterable<String> l3 = l1.map((e) => e > 10 ? "大" : "小");
  Iterable<num> l4 = l1.map((e) => e > 12 ? e / 2 : e * 2);
  print(l2); // (false, true, false, false, true, true, false)
  print(l3); // (小, 大, 小, 小, 大, 大, 小)
  print(l4); // (16, 24, 8, 12, 11.0, 17.0, 20)

toSet 将 List 转换为 Set，得到去重后的元素

List<int> l1 = [8, 12, 8, 6, 22, 12, 10];
  Set<int> l2 = l1.toSet();
  print(l2); // {8, 12, 6, 22, 10}

asMap 将 List 转换为 Map，key 为原数组的索引，value 为原数组的元素

List<String> l1 = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"];
  Map map = l1.asMap();
  print(map); // {0: 周一, 1: 周二, 2: 周三, 3: 周四, 4: 周五, 5: 周六, 6: 周日}

sort 数组排序(原数组发生改变)

List<int> l1 = [8, 12, 8, 6, 22, 12, 10];
  l1.sort();
  List<String> l2 = ["f","d","b","c","a","e"];
  l2.sort();
  print(l1); // [6, 8, 8, 10, 12, 12, 22]
  print(l2); // [a, b, c, d, e, f]

join 用指定字符连接数组中每个元素，返回 String

List<int> l1 = [8, 12, 8, 6, 22, 12, 10];
  String str1 = l1.join();
  String str2 = l1.join("");
  String str3 = l1.join(" ");
  String str4 = l1.join(",");
  String str5 = l1.join("-");
  print(str1); // 81286221210
  print(str2); // 81286221210
  print(str3); // 8 12 8 6 22 12 10
  print(str4); // 8,12,8,6,22,12,10
  print(str5); // 8-12-8-6-22-12-10

cast 将一个数组的类型传递给未指定数据类型的数组

List<int> l1 = [8, 12, 8];
  var l2 = l1.cast(); // 指定 l2 的数据类型和 l1 的一样，都是 int 类型
  l2.add(6);
  print(l1); // [8, 12, 8, 6]
  l2.add("ddd");
  print(l1); // 报错，提示无法将 String 类型的数添加到 int 类型的数组中

List.generate 快速生产 Flutter 中的 Widget

List<int> l1 = [8, 12, 8, 6, 22, 12, 10];
...
children: List.generate(l1.length, (index){
    return Text("$index");
 })

reduce 用指定的函数方式对数组中的所有元素做连续操作，并将结果返回

List<int> l1 = [1, 2, 3, 4];
  int res1 = l1.reduce((a, b) => (a * b)); // 元素依次相乘
  int res2 = l1.reduce((a, b) => (a + b)); // 元素依次相加
  print(res1); // 1*2*3*4 = 24
  print(res2); // 1+2+3+4 = 10

fold 根据一个现有数组和一个初始参数值 initValue，指定参数条件操作现有数组的所有元素，并返回处理的结果

List<int> l1 = [1, 2, 3, 4];
  // 2 为初始参数值，后面定义的方法为该初始值和原数组之间的处理方式
  int res1 = l1.fold(2, (a, b) => (a * b)); // 相乘
  int res2 = l1.fold(2, (a, b) => (a + b)); // 相加
  print(res1); // 2*(1*2*3*4) = 48
  print(res2); // 2+(1+2+3+4) = 12

expand 根据现有数组，指定一个处理方式，返回一个 Iterable

List<int> l1 = [1, 2, 3, 4];
  // 将 l1 数组内的每一个元素都和指定的表达式组相操作
  Iterable<int> l2 = l1.expand((e) => [e + 1]);
  Iterable<int> l3 = l1.expand((e) => [e + 1, e + 2]);
  Iterable<int> l4 = l1.expand((e) => [e + 2, e * 2]);
  Iterable<num> l5 = l1.expand((e) => [e * 2, e / 2]);
  Iterable<int> l6 = l1.expand((e) => [e, e + 1, e + 2]);
  print(l2); // (2, 3, 4, 5)
  print(l3); // (2, 3, 3, 4, 4, 5, 5, 6)
  print(l4); // (3, 2, 4, 4, 5, 6, 6, 8)
  print(l5); // (2, 0.5, 4, 1.0, 6, 1.5, 8, 2.0)
  print(l6); // (1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6)

shuffle 随机排列指定数组(修改了原数组)

List<int> l1 = [1, 2, 3, 4];
  l1.shuffle();
  print(l1); // [1, 4, 2, 3]
  l1.shuffle();
  print(l1); // [2, 1, 3, 4]

终于写完了，属实不易，可以看到 Dart 中 List 数组中的方法还是比较多的，其中关于查询数据的居多，虽然每个方法都举了一个或者多个例子，不过我觉得还是缺一张总览表，用来记载每个方法的名称和作用，也给大家整理好了，就是下面这几张表了

汇总


"添加"数据的方法


方法名

作用

add

添加一个元素到数组末尾

addAll

合并两个数组

insert

在指定索引处插入一个值

insertAll

在指定索引处插入一个数组

"删除"数据的方法


方法名

作用

remove

删除指定元素

removeAt

删除指定索引位置处的元素

removeLast

删除数组的最后一个元素

clear

清空数组

removeWhere

根据指定条件删除元素

removeRange

删除指定索引范围内的元素(含头不含尾)

"修改"数据的方法


方法名

作用

List [index]

修改指定索引位置元素的值

fillRange

用相同的值替换指定索引范围内的所有元素(含头不含尾)

replaceRange

用某一数组替换指定索引范围内的所有元素(含头不含尾)

setRange

范围替换数组中的值(含头不含尾)

setAll

从指定索引位置开始，使用第二个数组内的元素依次替换掉第一个数组中的元素

"查询"数据的方法


方法名

作用

elementAt

获取指定索引位置处的元素

contains

判断数组中是否含有指定元素

indexOf

获取指定元素在数组中的索引

lastIndexOf

从后向前查找指定元素在数组中的索引

indexWhere

返回第一个满足条件的元素的索引

lastIndexWhere

从后向前找，返回第一个满足条件的元素的索引

where

根据指定条件，函数筛选每个元素，符合条件的元素组成一个新的 Iterable

firstWhere

返回第一个满足条件的元素

lastWhere

从后向前查找第一个满足条件的元素

singleWhere

获取满足指定条件的唯一元素

retainWhere

根据指定条件筛选元素(改变了原数组)

any

判断数组中是否有满足指定条件的元素

every

判断数组中是否每个元素都满足指定的条件

take

从索引 0 位置处，取指定个数的元素

takeWhile

从索引 0 位置处，查询满足指定条件的元素，直到出现第一个不符合条件的元素，然后返回前面符合条件的元素

skip

跳过指定个数的元素，返回后面的元素

skipWhile

根据指定条件，找到第一个不符合条件的元素，然后将该元素后面的所有元素返回

sublist

从指定索引处截取数组

getRange

截取指定索引范围内的元素

whereType

从混合类型的数组中，筛选出指定类型的元素

"常用"的方法

方法名

作用

forEach

遍历数组中的元素

map

遍历数组中的所有元素，可以对元素进行处理，并返回新的 Iterable

toSet

将 List 转换为 Set，得到去重后的元素

asMap

将 List 转换为 Map，key 为原数组的索引，value 为原数组的元素

sort

数组排序(原数组发生改变)

join

用指定字符连接数组中每个元素，返回 String

cast

将一个数组的类型传递给未指定数据类型的数组

List.generate

快速生产 Flutter 中的 Widget

reduce

用指定的函数方式对数组中的所有元素做连续操作，并将结果返回

fold

根据一个现有数组和一个初始参数值 initValue，指定参数条件操作现有数组的所有元素，并返回处理的结果

expand

根据现有数组，指定一个处理方式，返回一个 Iterable

shuffle

随机排列指定数组(修改了原数组)

至此，关于 Dart 中 List 数组的常用方法已经总结完毕，显示已接近一万字，这篇文章实在是太肝了，不过整理下来自己也掌握了很多