Dart入门-集合类型-列表(List)

void listDemo() {
  // 1.list的创建
  listCreate();
  // 2.多种类型的输出
  listPrint();
  // 3.添加数据
  listAddElement();
  // 4.删除数据
  listRemoveElement();
  // 5.更改列表元素
  changeTheListElements();
  // 按顺序迭代列表
  List<String> names = ["Alice", "Daphne", "Elizabeth", "Joanna"];
  names.forEach((name){
    print(name);
  });
}

1.List创建及属性

void listCreate() {
  // 固定长度的列表，一旦定义就无法改变长度
  List<int> fixedLengthList = List(5);
  fixedLengthList[0] = 66;
  print(fixedLengthList);
  print(fixedLengthList[0]);

  // 可改变长度的列表，可以根据需要改变长度
  List<int> growableList =[];
  growableList.add(100);
  growableList.length = 5;
  growableList[4] = 100;
  growableList[1] = 1;
  print(growableList);
  List growableListB = List(500);
  print(growableListB.length);
  List fa = [1,2,5];
  // 不可变列表
  List fb = List.unmodifiable(fa); 
  // fb[0] = 100;
  // fb.removeLast();
  print(fb);
  // 可变列表
  List fc = List.from(fa); 
  fc[0] = 100;
  print(fc);
  
  // 创建一个长度为4值为1的列表，为所有元素统一赋值
  List fd = List<int>.filled(4, 1); 
  print(fd);
  List e = [14,20,3,4];
  // 用生成器给所有元素赋初始值
  List fe = List<int>.generate(4, (int index){ // 也是可变数组
    print(index);
    return e[index];
  });
  // 相关属性
  print(fe);
  print(fe.first);
  print(fe.last);
  print(fe.hashCode);
  print(fe.isEmpty);
  print(fe.isNotEmpty);
  print(fe.iterator); // 返回一个新的迭代器 不知道有啥用
  print(fe.reversed);
  print(fe.removeLast());
  print(fe);
  print(fe.runtimeType);
  fe.length = 1;
  print(fe.single); // 列表是否是只有一个元素，否则报错
}

2.返回多种类型的输出

void listPrint(){
  List growableList = List.from([1,2,3,4,5]);
  // 返回列表的字符串表示
  String string = growableList.toString();
  print(string);
  // 返回列表的集合表示
  print(growableList.toSet());
  // 返回字符串的列表表示
  print(growableList.toList());
  // 用指定字符连接列表元素
  print(growableList.join(','));

  print('---------分割线---------');

  // 各种查询输出方法
  List<String> names = ['Abbey', 'Fallon', 'Xenia', 'Callie', 'Callie'];
  // 列表中是否包含指定元素
  print(names.contains('Fallon'));
  // 返回列表中的第几个元素
  print(names.elementAt(2));
  print(names[2]);
  // 返回列表中第一个匹配元素的下标
  print(names.indexOf('Callie'));
  // 返回列表中最后一个匹配元素的下标
  print(names.lastIndexOf('Callie'));

  List<String> colors = ['red', 'green', 'blue', 'orange', 'pink'];
  // 返回从开始下标（包括）到结束下标（不包括）元素的列表
  print(colors.sublist(1, 3));
  // 返回从开始下标（包括）到最后一个元素的列表
  print(colors.sublist(1));
}

3.添加元素

void listAddElement(){
  List growableList = List();
  // 增加一个元素到末尾
  growableList.add(100);
  // 增加一个元素到指定下标
  int index = 0;
  dynamic element = 20;
  print(growableList.length);
  growableList.insert(index, element);
  print(growableList);
  // 增加一个列表到列表末尾
  List list = [20,3];
  growableList.addAll(list);
  print(growableList);
  // 增加一个列表到指定位置
  growableList.insertAll(index, list);
  print(growableList);
}

4.删除元素

void listRemoveElement(){
  List list = [1,2,3,4,3,4,5];
  print(list);
  // 删除列表中匹配的第一个元素
  list.remove(3);
  print(list);
  // 移除列表中第几一个元素
  list.removeAt(1);
  print(list);
  // 移除列表中最后一个元素
  list.removeLast();
  // 移除列表的所有元素
  list.clear();
  print(list);
  List listA = [1,2,3,4,5];
  // listA.replaceRange(start, end, replacement)
  // 删除并替换开始下标（包括）至结束下标（不包括）内的元素
//   /**Removes the objects in the range [start] inclusive to [end] exclusive and inserts the contents of [replacement] in its place.
// List<int> list = [1, 2, 3, 4, 5];
// list.replaceRange(1, 4, [6, 7]);
// list.join(', '); // '1, 6, 7, 5'
// The provide range, given by [start] and [end], must be valid. A range from [start] to [end] is valid if 0 <= start <= end <= len, where len is this list's length. The range starts at start and has length end - start. An empty range (with end == start) is valid.

// This method does not work on fixed-length lists, even when [replacement] has the same number of elements as the replaced range. In that case use [setRange] instead *//
  listA.replaceRange(1, 4, [6,'a',8]);
  print(listA);
  List listB = [1,2,3,4,5];
  // listA.replaceRange(start, end, replacement)
  // 删除并替换开始下标（包括）至结束下标（不包括）内的元素
  listB.removeRange(1, 4);
  print(listB);// [1,5]
  List<String> numberA = ['one','two','trhee','four'];
  // 从此列表中删除满足的所有对象。
  numberA.removeWhere((item){
    return item.length == 3;
  });
  print(numberA);
}

5.对列表元素做一些改动

void changeTheListElements() {
  List<String> listA = ['a', 'b', 'c','d'];
  // 从第几个元素开始覆盖原列表
  /**List.setAll(int index, Iterable<String> iterable) → void
   * 此操作不会增加此长度。
   * [index]必须是非负数且不大于[length]。
   * [iterable]的元素数量不能超过[index]到[length]的元素。
   * 如果iterable基于此列表，则其值可能会在/ setAll期间/更改 */
  listA.setAll(1, ['bee', 'sea']);
  print(listA);

  List<int> listB = [1, 2, 3, 4, 5];
  // 对列表进行随机排序
  listB.shuffle();
  print(listB);

  // 对列表进行顺序排序
  /** 
   * List.sort([(int, int) → int compare]) → void
   * 根据[compare]函数指定的顺序对此列表进行排序。
   * [compare]函数必须充当[Comparator]。
   * 
   */

  List<String> numbers = ['two','three', 'four'];
  // Sort from shortest to longest.
  numbers.sort((a, b) => a.length.compareTo(b.length));
  print(numbers);  // [two, four, three]
  // The default List implementations use [Comparable.compare] if [compare] is omitted.
  List<int> nums = [13, 2, -11];
  nums.sort();
  print(nums);  // [-11, 2, 13]
}