Dart数组基本属性与操作

  1.   - 一、数组的定义
  2.         - 1、定义固定类型数组
  3.         - 2、定义固定长度数组
  4.         - 3、定义混合类型数组
  5.   - 二、数组的常用属性
  6.         - 1、获取数组长度 - length
  7.         - 2、获取数组第一个元素 - first
  8.         - 3、获取数组最后一个元素 - last
  9.         - 3、获取倒序迭代器 - reversed
  10.         - 4、判断数组是否为空 - isEmpty
  11.         - 5、判断数组是否为非空 - isNotEmpty
  12.   - 三、数组的常用方法
  13.         - 1、添加元素 - add
  14.         - 2、批量添加 - addAll
  15.         - 3、指定位置添加 - insert
  16.         - 4、指定位置批量添加 - insertAll
  17.         - 5、删除指定值 - remove
  18.         - 6、删除指定索引 - removeAt
  19.         - 7、删除指定范围 - removeRange
  20.         - 8、删除最后一个 - removeLast
  21.         - 9、删除符合条件的所有元素 - removeWhere
  22.         - 10、删除所有元素 - clear
  23.         - 11、修改数组中某区间元素为指定值 - setRange
  24.         - 12、修改指定索引后的数组值 - setAll
  25.         - 13、修改指定索引后的数组值 - setAll
  26.         - 13、替换 - replaceRange
  27.         - 14、将指定区间替换成某个固定值- fillRange
  28.         - 15、获取某个区间的值- getRange
  29.         - 16、查询指定区间的值- getRange
  30.         - 17、判断数组内是否有满足条件的元素- any
  31.         - 18、判断数组所有元素是否都满足设定条件 - every
  32.         - 19、判断数组是否包含某个元素 - contains
  33.         - 20、获取满足条件的第一个元素 - firstWhere
  34.         - 21、获取满足条件的最后一个元素 - lastWhere
  35.         - 22、从制定位置开始，获取满足条件的第一个元素的索引 - indexWhere
  36.         - 23、获取满足条件的最后一个元素的索引(倒叙查询) - lastIndexWhere
  37.         - 24、从指定位置开始，获取指定值的索引 - indexOf
  38.         - 25、从指定位置开始，倒叙获取指定值的索引 - lastIndexOf
  39.         - 26、获取唯一元素 - singleWhere
  40.         - 27、将数组用指定字符拼接成字符串 - join
  41.         - 28、数组去重 - toSet
  42.         - 29、数组遍历 - forEach
  43.         - 30、按指定条件返回Iterable - map
  44.         - 31、累加器 - reduce
  45.         - 32、排序 - sort

学习flutter过程中，总结一些list的操作方法，记录下，老了，记忆力查了，方便往后查询使用。后面慢慢补充

一、数组的定义

1、定义固定类型数组

| 1
2
3

// 定义固定类型的数组
var list = List();
print(‘$list - length: ${list.length}’); // 输出 [] - 0

2、定义固定长度数组

| 1
2

var list2 = List(2);
print(‘$list2’); // [null, null]

3、定义混合类型数组

| 1
2
3
4

var list3 = List();
list3.add(2);
list3.add(‘value’);
print(list3); // [2, ‘value’]

二、数组的常用属性

1、获取数组长度 - length

| 1
2

var list = [1, 2, 3, 4];
print(list.length); // 4

2、获取数组第一个元素 - first

| 1
2

var list = [1, 2, 3, 4];
print(list.first); // 1

3、获取数组最后一个元素 - last

| 1
2

var list = [1, 2, 3, 4];
print(list.last); // 4

3、获取倒序迭代器 - reversed

| 1
2

var list = [1, 2, 3, 4];
print(list.reversed); // (4, 3, 2, 1)

4、判断数组是否为空 - isEmpty

| 1
2

var list = [1, 2, 3, 4];
print(list.isEmpty); // false

5、判断数组是否为非空 - isNotEmpty

| 1
2

var list = [1, 2, 3, 4];
print(list.isNotEmpty); // true

三、数组的常用方法

1、添加元素 - add

| 1
2
3

var list = [];
list.add(1);
print(list); // [1]

2、批量添加 - addAll

| 1
2
3
4

var list = [1, 2, 3, 4];
var list2 = [0, 20, 40];
list.addAll(list2);
print(list); // [1, 2, 3, 4, 0, 20, 40]

3、指定位置添加 - insert

| 1
2
3

var list = [1, 2, 3, 4];
list.insert(2, 90);
print(list); // [1, 2, 90, 3, 4]

4、指定位置批量添加 - insertAll

| 1
2
3
4

var list = [1, 2, 3, 4];
var list2 = [0, 20, 40];
list.insertAll(2, list2);
print(list); // [1, 2, 0, 20, 40, 3, 4]

5、删除指定值 - remove

| 1
2
3

var list = [1, 2, 6, 4];
list.remove(6);
print(list); // [1, 2, 4]

6、删除指定索引 - removeAt

| 1
2
3

var list = [1, 2, 6, 4];
list.removeAt(2);
print(list); // [1, 2, 4]

7、删除指定范围 - removeRange

| 1
2
3

var list = [1, 2, 6, 4];
list.removeRange(2, 4);
print(list); // [1, 2]

8、删除最后一个 - removeLast

| 1
2
3

var list = [1, 2, 6, 4];
list.removeLast();
print(list); // [1, 2, 6]

9、删除符合条件的所有元素 - removeWhere

| 1
2
3
4

var list = [1, 2, 6, 4, 6];
// 删除大于3的元素
list.removeWhere((v) => v > 3);
print(list); // [1, 2]

10、删除所有元素 - clear

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.clear();
print(list); // []

11、修改数组中某区间元素为指定值 - setRange

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.setRange(1, 4, [9, 9, 9]); // 将索引1到4的值修改为9
print(list); // [1, 9, 9, 9, 6]

12、修改指定索引后的数组值 - setAll

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.setAll(2, [2, 4, 5]); // 设置索引为2开始的后面3位数分别为2，4，5
print(list); // [1, 2, 2, 4, 5]

13、修改指定索引后的数组值 - setAll

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.setAll(2, [2, 4, 5]); // 设置索引为2开始的后面3位数分别为2，4，5
print(list); // [1, 2, 2, 4, 5]

13、替换 - replaceRange

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.replaceRange(0, 4, [3]); // 将索引从0-4的元素替换成3
print(list); // [3, 6]

14、将指定区间替换成某个固定值- fillRange

| 1
2
3

var list = [1, 2, 6, 4, 6];
list.fillRange(2, 4, 1); // 将区间2到4的元素替换成数值1
print(list); // [1, 2, 1, 1, 6]

15、获取某个区间的值- getRange

| 1
2
3

// 返回迭代器
var list = [1, 2, 6, 4, 6];
print(list.getRange(2, 4)); // 返回Iterable (6, 4)

16、查询指定区间的值- getRange

| 1
2
3
4

// 返回迭代器
var list = [1, 2, 6, 4, 6];
print(list.sublist(2)); // [6, 4, 6] ， 返回从索引2开始的所有数据
print(list.sublist(2, 4)); // [6, 4]， 返回索引从2到4的数据

17、判断数组内是否有满足条件的元素- any

| 1
2
3
4
5

var list = [3, 2, 6, 4, 6];
// 数组中是否有大于2的元素
print(list.any((v) => v > 2)); // true
// 数组中是否有大于6的元素
print(list.any((v) => v > 6)); // false

18、判断数组所有元素是否都满足设定条件 - every

| 1
2
3
4
5

var list = [3, 2, 6, 4, 6];
// 数组中所有元素是否都大于1
print(list.every((v) => v > 1)); // true
// 数组中所有元素是否都大于2
print(list.every((v) => v > 2)); // false

19、判断数组是否包含某个元素 - contains

| 1
2
3
4
5

var list = [3, 2, 6, 4, 6];
// 数组中是否包含3
print(list.contains(3)); // true
// 数组中是否包含1
print(list.contains(1)); // false

20、获取满足条件的第一个元素 - firstWhere

| 1
2
3
4
5
6
7
8

| var list = [3, 2, 3, 6, 4, 3];
// 获取最后一个大于2的元素
print(list.lastWhere((v) => v > 2)); // 3

// 如果未查找到所制定条件的元素，进入orElse参数
list.firstWhere((v) => v > 6, orElse: () {
print(3333);
}); | | —- | —- |

21、获取满足条件的最后一个元素 - lastWhere

| 1
2
3
4
5
6
7
8

| var list = [3, 2, 6, 4, 6];
// 获取最后一个大于4的元素
print(list.lastWhere((v) => v > 4)); // 6

// 如果未查找到所制定条件的元素，进入orElse参数
list.firstWhere((v) => v > 6, orElse: () {
print(3333);
}); | | —- | —- |

22、从制定位置开始，获取满足条件的第一个元素的索引 - indexWhere

| 1
2
3
4
5
6
7
8

var list = [3, 2, 6, 4, 6];
// 查询第一个大于4的元素索引值
print(list.indexWhere((v) => v > 4)); // 2
// 从索引3开始，查询第一个大于4的元素索引值
print(list.indexWhere((v) => v > 4, 3)); // 4
// 从索引3开始，查询第一个大于9的元素索引值
// 若不存在，返回-1
print(list.indexWhere((v) => v > 9, 3)); // -1

23、获取满足条件的最后一个元素的索引(倒叙查询) - lastIndexWhere

| 1
2
3
4
5
6
7

var list = [3, 2, 6, 4, 6];
// 获取最后一个大于4的元素索引值
print(list.lastIndexWhere((v) => v > 2)); // 4
// 从索引2开始，查询最后一个大于4的元素索引值
print(list.lastIndexWhere((v) => v > 3, 3)); // 2
// 如果没有，返回-1
print(list.lastIndexWhere((v) => v > 9)); // -1

24、从指定位置开始，获取指定值的索引 - indexOf

| 1
2
3
4

var list = [3, 2, 6, 4, 6];
// 从索引3开始，获取6第一次出现时的索引值，如果不存在，返回 -1
print(list.indexOf(6, 3)); // 4
print(list.indexOf(6)); // 2

25、从指定位置开始，倒叙获取指定值的索引 - lastIndexOf

| 1
2
3
4
5
6

var list = [3, 2, 6, 4, 6];
// 从索引3开始，获取6第一次出现时的索引值，如果不存在，返回 -1
var list = [3, 2, 6, 4, 6];
print(list.lastIndexOf(6, 3)); // 4
print(list.lastIndexOf(6)); // 2
print(list.lastIndexOf(7)); // -1

26、获取唯一元素 - singleWhere

| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

| var list = [3, 2, 6, 4, 6];
// 获取大于6的唯一元素，不存在该元素，执行orElse
print(list.singleWhere((v) => v > 6, orElse: () {
print(‘ —- ‘);
})); // —-

// 获取等于2的唯一元素，存在，返回2
print(list.singleWhere((v) => v == 2, orElse: () {
print(‘ —- ‘);
})); // 2

// 获取等于6的唯一元素，存在该元素，但是出现次数不唯一，不会执行orElse，直接抛出错误，进入catch
print(list.singleWhere((v) => v == 6, orElse: () {
print(‘ —- ‘);
})); // error | | —- | —- |

27、将数组用指定字符拼接成字符串 - join

| 1
2
3

var list = [3, 2, 6, 4, 6];
// 将数组转换为用&拼接的字符串
print(list.join(‘&’)); // 3&2&6&4&6

28、数组去重 - toSet

| 1
2

var list = [3, 2, 6, 4, 6];
print(list.toSet()); // {3, 2, 6, 4}

29、数组遍历 - forEach

| 1
2
3
4
5
6
7
8
9
10
11
12

var list = [3, 2, 6, 4, 6];
list.forEach((element) {
// element 为list内的每个元素
print(element);
/
3
2
6
4
6
/
});

30、按指定条件返回Iterable - map

| 1
2
3
4
5
6
7
8
9
10
11

var list = [3, 2, 6, 4, 6];
// 将list所有元素加1并返回Iterable
var x = list.map((e) {
return e + 1;
});
print(x); //(4, 3, 7, 5, 7)
// 将list所有元素与4比较并返回boolean Iterable
var y = list.map((e) {
return e > 4;
});
print(y);//(false, false, true, false, true)

31、累加器 - reduce

| 1
2
3
4
5
6
7
8
9
10
11
12
13
14

var list = [3, 2, 6, 4, 6];
// 将每次返回值作为value循环执行。最终返回最后一次执行值
var x = list.reduce((value, element) {
print(‘value: $value - element: $element’);
/*
每次的执行结果
value: 3 - element: 2
value: 5 - element: 6
value: 11 - element: 4
value: 15 - element: 6
/
return value + element;
});
print(‘x: $x’); // x: 21

32、排序 - sort

| 1
2
3
4
5
6
7

var list = [3, 2, 6, 4, 6];
// 按回调中的return结果正负数来排序
// a - b 为升序， b - a为降序
list.sort((a, b) {
return a - b;
});
print(list); // [6, 6, 4, 3, 2]