Flutter开发篇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); // 列表是否是只有一个元素，否则报错
    
 }

 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));
    
 }

 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);
    
 }

 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.
    
   24. // 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);
    
 }

 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]。
    
    * */
    
   25.   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]
    
 }