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]

}