【Dart学习】--Dart之数组(List)的相关方法总结

一，初始化List

• 非固定长度list
  

  var testList = List();
  print(testList.length);//输出0

• 固定长度List
  

  var testList2 = List(2);
  print(testList2.length);//输出2

• 元素类型固定：
  

  var testList3 = List<String>();
  testList3.add("哈哈哈");
  //testList3.add(1);//报错，1不是String类型

• 直接赋值
  

  var testList4 = [123,2312];
  print(testList4.length);
  
  var testList5 = [true,"嘎嘎嘎",1];
  testList5.add(1.6);//可以添加

二，常用字段

• length属性，返回队列长度
  

  var testList6 = [1,"2",3,34532,555];
  //length属性，返回队列长度
  print(testList6.length);

• isEmpty属性，返回列表是否为空
  

  //isEmpty属性，返回列表是否为空
  print(testList6.isEmpty);

• isNotEmpty属性，返回列表是否有元素
  

  //isNotEmpty属性，返回列表是否有元素
  print(testList6.isNotEmpty);

• first获取List中的第一个元素
  

  //获取List中的第一个元素
  print("获取list中的第一个元素${testList6.first}");

• last获取List中的最后一个元素
  

     //获取List中最后一个元素
      var testList = [1,2,3,4];
      testList.add(14);
      testList.add(‘111‘);
      print(testList.last); 

• [index] 获取List中某个位置上的元素（index为位置索引）
  

    //获取List中某个位置上的元素
      var testList = [1,2,3,4];
      testList.add(14);
      testList.add(‘111‘);
      print(testList[2]); 

三，数组（List）增，删，改，查

• 添加数据
  • 添加一条数据　　
    

     //添加一条数据
     var testList = List();
         testList.add(14);
         testList.add(‘111‘);

  • 向规定长度的数组添加数据
    
    • 错误的方法
      

       //下面的程序会报错“Unsupported operation: Cannot add to a fixed-length list”固定长度的list不能通过add添加数据
       var testList = List(3);
          testList.add(14);
          testList.add(‘111‘);

    • 正确的添加方法

      //固定长度的List使用以下方式可以设置数据
          var testList = new List(3);
          testList[0] = ‘雷锋‘;
          testList[1] = ‘18‘;
          testList[2] = ‘好人‘;
          print(testList[2]);　　

  • 添加全部元素
    

       //把一个数组元素全部添加到另外一个数组里
        var testList1 = new List();
        var testList2 = [‘雷锋‘,‘18‘,‘好人‘];
        testList1.addAll(testList2);
        print(testList1.length);

  • 向指定位置添加元素
    

     //向指定位置添加元素，如果位置越界就会报错
        var testList = [‘雷锋‘,‘18‘];
        testList.insert(2,‘好人‘);
        print(testList.length);

  • 向指定位置添加一个新的List，第二个参数为实现了Iterable接口的对象均可

     //向指定位置添加一个新的List，第二个参数为实现了Iterable接口的对象均可
        var testList1 = [‘雷锋‘,‘18‘];
        var testList2 = [‘焦裕禄‘,‘45‘];
        testList1.insertAll(2,testList2);
        print(testList1.length);

  • 将另外一个实现了iterabe接口的数据拼接到当前的List后面

    //将另外一个实现了iterabe接口的数据拼接到当前的List后面 
    Set testSet = Set();
    testSet.add(123);
    testSet.add(123);
    testSet.add(123); 
    var testFollowedBy = testList6.followedBy(testSet);
    print("testFollowedBy ${testFollowedBy}");

• 删除数据
  • 删除指定元素
    

    //删除指定元素
    testList.remove("哈哈哈");
    print(testList);

• • 删除最后一个元素
    

    //删除最后一个元素
    testList.removeLast();
    print(testList);

  • 删除指定位置的元素

    //删除指定位置的元素
    testList.removeAt(testList.length - 1);
    print(testList);

  • 删除指定区域的元素

    //删除指定区域的元素
    testList.removeRange(0,1);
    print(testList);

  • 下面这个方法是将列表List中的toString之后的字符串的长度等于3的元素全部删除

    //下面这个方法是将列表List中的toString之后的字符串的长度等于3的元素全部删除
    testList6.removeWhere((item) => item.toString().length == 3);
    print("删除列表中toString后长度为3的元素：==> $testList6");

• 修改数据

  • 设置元素，下面的方法将testList6中的第一个和第二个元素设置为testList中的元素

    //设置元素，下面的方法将testList6中的第一个和第二个元素设置为testList中的元素
    //如果testList中的元素个数不够需要替换的元素个数，会报错
    //如果testList中的元素个数大于需要替换的元素个数，可以通过设置第四个参数，表示跳过testList的前面几个元素，默认为0
    //如果设置了第四个参数之后testList中的元素个数不够需要替换的元素个数，会报错
    testList6.setRange(0, 2, testList,1);
    print("testList===>${testList}");

  • 替换列表中的元素
    

    //替换列表中的元素
    //前两个参数表示要替换列表中的元素的位置，如下面的表示将列表中第三个到第十个元素替换为testList5中的元素
    //第二个参数<=列表的长度
    //第一个参数<=第二个参数，否则会报错
    //就是list会首先删除第一个参数到第二个参数之前的元素，然后将需要替换的list添加在第一个参数的位置。
    print(testList6.length);
    testList6.replaceRange(10, 10, testList7);
    print(testList6);

  • 使用一个值替换List中的指定位置的全部值
    

    //使用一个值替换List中的指定位置的全部值
    //比如下面的操作结果就是将List中第三个和第四个元素使用item的值替换
    var item ="哼哼哼";
    testList6.fillRange(3, 5,item);
    print("fillRange item ===>$item");
    print(testList6);

  • 设置list列表中的元素
    

    //设置list列表中的元素
    //第一个参数表示从第几个元素开始
    //下面的例子表示从第二个位置开始将后面的tetsList7.length个元素替换为testList7中的元素
    //如果第一个参数+第二个参数.length大于要修改的list的length会报错
    print(testList6);
    testList6.setAll(2, testList7);
    print("setAll() ===> $testList6");

• 查询操作
  • 截取一个List中的其中几个元素，第一个参数表示开始的位置，第二个参数为可选参数，表示结束的位置　
    

    //截取一个List中的其中几个元素，第一个参数表示开始的位置，第二个参数为可选参数，表示结束的位置
    //如果第二个参数大于被截取List的长度，会报错。
    var subList = testList6.sublist(0,3);
    print("截取到新的List==> ${subList}");

  • 获取指定位置区间的元素，并返回一个新的list,和subList的区别是subList返回一个新的List，而getRange返回一个实现了Iterable接口的对象

    //获取指定位置区间的元素，并返回一个新的list,和subList的区别是subList返回一个新的List，而getRange返回一个实现了Iterable接口的对象
    //返回一个实现了Iterable接口的对象
    var rangeList = testList6.getRange(5,10);
    print("rangeList===>${rangeList}");
    print(testList6);

  • 将满足条件的元素保留下来，不满足条件的元素删除
    

    //将满足条件的元素保留下来，不满足条件的元素删除
    //如下面的例子是将元素中字符长度=3的元素保存下来
    testList6.retainWhere((obj) => obj.toString().length == 3);
    print(testList6);

  • 查看元素最后一次出现的位置
    

    //查看元素最后一次出现的位置
    //第二个参数为可选参数，表示查找的位置
    //如果不传，默认查找全部的List
    //如果传递了第二个值，则从0查找到第二个值所指定的位置
    //没有查找到的话返回-1
    //第二个值可以大于List的length
    //第二个参数用start来命名，可以认为这个方法是从后向前开始查找，这样就很好理解start表示的是开始位置了。
    testList6.insert(4, "嘻嘻嘻");
    testList6.add("哼哼哼");
    print(testList6);
    var testPosition = testList6.lastIndexOf("哼哼哼",testList6.length + 100);
    print("testPosition ====> $testPosition");

  • 元素的索引,没有找到元素会返回-1
    

    //元素的索引,没有找到元素会返回-1
    //可以和上面的lastIndexof形成对比，
    //第二个参数可以指定查找的范围
    print(testList6.indexOf("哼哼哼",5));

  • 遍历查询有没有满足条件的数据，如果有就返回true，没有就返回false
    

    //遍历查询有没有满足条件的数据，如果有就返回true，没有就返回false
    //参数传入一个返回bool的函数
    var testExit = testList6.any((item) => checkData(item));
    print("textExit==>$testExit");

  • 遍历查询是不是所有的数据都满足这个条件，如果有不满足的数据，直接返回false
    

    //遍历查询是不是所有的数据都满足这个条件，如果有不满足的数据，直接返回false
    bool testEvery = testList6.every((item) => checkData(item));
    print("testEvey ===> $testEvery");　　

•  对比any和every方法：
  checkData()用来查看传入的参数是否为空，如果参数为空，就返回true，如果参数不为空，就返回false
  • 结合any和every方法的源码：
     any方法的源码中，遍历查询是否有满足条件的元素，如果找到满足条件的元素，那么直接返回true，
     every方法的源码中遍历查询有没有不满足条件的元素，如果发现有不满足的元素，直接返回false
  • 针对checkData()方法来说
    any在遍历的时候会将每一个元素传入checkData中，如果有一个元素是空的，此时就会直接返回true，目前返回了false，说明在testList6中没有为空的元素
    every在遍历的时候将每一个元素传入checkData中，查看是否全部元素都是空的，如果其中有一个元素不是空的，就直接返回false,因此在checkData中由于第一个元素就不是空的，所以不满足每一个元素都是空的条件，直接返回false

• • 这个方法相当于查看List中的数据类型是不是都是指定的数据类型，如果发现List中存在不是<>中指定的数据类型就会报错
    

    //这个方法相当于查看List中的数据类型是不是都是指定的数据类型，
    //如果发现List中存在不是<>中指定的数据类型就会报错 
    print(testList6);
    List<String> testStringList = testList6.cast<String>();
    print("testIntList ===> $testStringList");

  • 查看List中是否存在指定元素

    //查看List中是否存在指定元素
    print("是否存在哼哼哼${testList6.contains("哼哼哼")}");

  • 查找指定位置的元素

    //查找指定位置的元素
    //传入的参数必须是合法的，也就是必须在是int类型，然后必须在0到list.length之间
    //从源码也可以看出：会首先判断传入的蚕食是否是int类型，然后会判断参数是否小于0，接着执行循环，开始遍历，如果遍历完了还没找到指定的位置
    //就说明这个指定的位置有问题。
    var position = testList6.elementAt(testList6.length - 1);
    print("position ====> $position");

  • 可以理解为将一个一维数组扩展为二维数组

    //可以理解为将一个一维数组扩展为二维数组
    var testList9 = testList2.expand((item) => [item,item.toString() + "啊"].toList());
    print("test expand ===> $testList9");
    //同时也可已经一个二维数组解封,解封时需要数组里面的ietm仍然是一个list
    var testList10 = [[12,12],[22,44]];
    var testList11 = testList10.expand((item) => item.toSet());
    print("test expand ===> $testList11");

  • 满足条件的第一个元素

    //满足条件的第一个元素
    //从源码可以看出，firstWhere方法会首先从列表中查找有没有满足条件的item，如果没有找到，会判断有没有
    //传入第二个参数，如果第二个参数不为空，就执行第二个参数的方法，如果第二个参数为空，就直接出错。
    var testFirstWhere = testList6.firstWhere((item) => checkExitHa(item),orElse: getHi);
    print("满足条件的第一个元素：$testFirstWhere");

  • 有条件地查询所需数据的位置

    //有条件地查询所需数据的位置
    //第一个参数是返回bool值的函数，第二个参数是起始位置
    //下面的例子是找出列表中元素toString之后长度是2的元素出现的位置
    testList6.insert(1, 23);
    testList6.add(34);
    int testIndexWhere1 = testList6.indexWhere((item) => getLength2(item.toString()));
    int testIndexWhere2 = testList6.indexWhere((item) => getLength2(item.toString()),3);
    print("testIndexWhere1 ${testIndexWhere1}");//输出1
    print("testIndexWhere2 ${testIndexWhere2}");//输出10

  • 有条件的查询需要查询的数据最后一次出现的位置

    //有条件的查询需要查询的数据最后一次出现的位置
    //这个方法具体的执行可以理解为倒序执行，从最后一个元素向前开始查找符合要求的数据
    //第二个参数就是指定开始执行的位置
    int testLastIndexWhere1 = testList6.lastIndexWhere((item) => getLength2(item.toString()));//输出10
    int testLastIndexWhere2 = testList6.lastIndexWhere((item) => getLength2(item.toString()),testList6.length - 2); //输出1
    print("testLastIndexWhere ${testLastIndexWhere1}");
    print("testLastIndexWhere ${testLastIndexWhere2}");

  • 返回满足条件的元素，第一个参数指定需要满足的条件，第二个参数为可选参数，指定不满足条件的时候需要执行的操作

    //返回满足条件的元素，第一个参数指定需要满足的条件，第二个参数为可选参数，指定不满足条件的时候需要执行的操作
    print("
     ${testList6}");
    var testLastWhere1 = testList6.lastWhere((item) => item.toString().length == 2 ? true : false);//没有找到符合要求的数据就会报出异常，程序会Crash
    var testLastWhere2 = testList6.lastWhere((item) => item.toString().length == 1 ? true : false,orElse: getHi);//没有找到符合要求的数据就会去执行getHi方法，返回getHi方法执行结果
    print("testLastWhere: ${testLastWhere1}");
    print("testLastWhere: ${testLastWhere2}");

  • 检查List中是否只有一个元素，如果只有一个元素会输出这个元素，如果没有元素会抛出没有数据的异常，如果多于一个元素，会抛出too many elemets异常

    //检查List中是否只有一个元素，如果只有一个元素会输出这个元素，如果没有元素会抛出没有数据的异常，如果多于一个元素，会抛出too many elemets异常
    List testList13 = List();
    testList13.add(123);
    print("
     testSingle:${testList13.single}");

  • 有条件的查询满足条件的元素是否只出现了一次

    //有条件的查询满足条件的元素是否只出现了一次
    //第二个参数是可选参数，用于当第一个条件不满足时执行的操作
    //具体执行的逻辑如下：
    //在List中查找满足条件的元素
    //如果没有找到满足条件的元素，查看orElse是否设置，如果设置，就执行orElse设置的函数
    //如果找到了满足条件的元素，并且满足条件的元素只有一个，输出这个元素的值
    //如果找到了满足条件的元素，但是满足条件元素的数量大于一个，就会抛出too many elements 异常，此时程序会直接crash,不会执行orElse设置的函数
    testList6.add(1);
    var testSingleWhere = testList6.singleWhere((item) => item.toString().length == 1,orElse: getHi);
    print("
    testSingleWhere ${testSingleWhere}, type is ${testSingleWhere.runtimeType} 
    ");

  • 取出前面多少个元素放在新的list中

    //取出前面多少个元素放在新的list中
    var testTake = testList6.take(3);
    print("
    testTake:${testTake},and type is ${testTake.runtimeType}
    ");

  • 返回List中满足条件的元素的惰性迭代

    //返回List中满足条件的元素的惰性迭代
    //从第一个元素开始查找符合条件的元素，一直查找到不符合条件的元素结束
    //注意这里是惰性迭代，也就是说如果满足条件的元素并不是按顺序排列的，分布在列表的任何位置，那么
    //这个方法查找只会查找处前面符合条件的元素，中间发现有元素不符合条件就会停止查找，即使后面还有符合条件的元素也不会再去查找了
    print(testList6);
    var testTakeWhile = testList6.takeWhile((item) => item.toString().length == 3);
    print("
    testTakeWhile:${testTakeWhile},and type is ${testTakeWhile.runtimeType}
    ");

  • 创建一个可包含此列表的新的列表

    //创建一个可包含此列表的新的列表
    //growable是一个可选参数，默认为true,表示创建一个可变长度的列表
    //如果传入false，则是一个固定长度的列表
    var testToList = testList6.toList(growable: true);
    var testToList1 = testList6.toList(growable: false);
    //testToList1.add("123");//异常：testToList是一个固定长度的列表，无法进行添加数据的操作
    //testToList1.removeAt(0);//异常：固定列表无法进行删除数据的操作
    print("
    testToList: ${testToList},and type id ${testToList.runtimeType}
    ");
    print("
    testToList1: ${testToList1},and type id ${testToList1.runtimeType}
    ");

  • 查找列表中满足条件的数据，条件由传入的函数参数决定

    //查找列表中满足条件的数据，条件由传入的函数参数决定
    var testWhere = testList6.where((item) => item.toString().length == 3);
    print("
    testWhere:${testWhere} and type is ${testWhere.runtimeType}
    ");

  • 取出List列表中指定类型的元素，并放入新的列表中

    //取出List列表中指定类型的元素，并放入新的列表中
    //如下面是将List中数据类型为String的元素全部取出放入到新的List中
    print(testList6);
    var testWhereType= testList6.whereType<String>();
    print("
    testWhereType:${testWhereType},and type is ${testWhereType.runtimeType}
    ");　　

四，其它操作方法

• 排序
  

  //排序
  testList6.sort((a,b) => a.toString().length.compareTo((b.toString().length)));
  print("根据字符的长度排序：${testList6}");

• 将List倒序排列之后赋给一个新的list，
  

  //将List倒序排列之后赋给一个新的list，
  var testList8 = testList6.reversed;
  print("倒序排列List===> $testList8");

• 根据position将list转换为对应的map Map<int,Element>
  

  //根据position将list转换为对应的map Map<int,Element>
  //也就是[0:element ......]
  var testMap = testList6.asMap();
  print("testMap ====> $testMap");

• 将List列表中的顺序打乱
  

  //将List列表中的顺序打乱
  //可以传入一个Random对象作为可选参数
  print(testList6);
  testList6.shuffle();
  print("shuffle ===> $testList6");

• 对列表中的数据做指定的操作
  

  //对列表中的数据做指定的操作
  //下面的操作是在列表开始的时候加上“哈哈哈”这个字符串然后将后面的元素都拼接起来
  print(testList6);
  String str = testList6.fold("哈哈哈",(pre,item) => pre + item );
  print("test fold ====> $str");

• List循环输出数据
  

  //List循环输出数据
  testList6.forEach((item) => print(item));

• 将List作为Iterator进行使用
  

  //将List作为Iterator进行使用
  print(testList6);
  var testIterator = testList6.iterator;
  while(testIterator.moveNext()){
  print("testIterator: ${testIterator.current}");//输出当前值
  }

• 使用join中的指定的字符串分隔List中的每个元素，并将其作为字符串返回
  

  //使用join中的指定的字符串分隔List中的每个元素，并将其作为字符串返回
  //通过源码可以看出，首先会将List作为Iterator来使用
  //如果Iterator中没有元素，就直接返回一个空的字符串，注意不是null，而是 ""
  //接着判断join()中的参数如果为空或者为 ""，直接将Iterator中的元素拼接然后返回
  //如果join()中有参数，就是用join中的参数作为分隔符拼接Iterator中的元素然后返回
  String testJoin1 = testList6.join();
  String testJoin2 = testList6.join(",");
  String testJoin3 = testList6.join("哒哒哒");
  print("join中无参数：${testJoin1}");
  print("使用,作为分隔符${testJoin2}");
  print("想要在最后一个元素之前的元素后面都添加一个字符串然后返回${testJoin3}");

• 下面的map方法和Map没有任何关系,执行结果和match更像
  

  //下面的map方法和Map没有任何关系,执行结果和match更像
  //这个方法的执行逻辑是将List中的每个元素拿出来和map(f)中传入的f函数条件进行比较
  //如果符合条件就会返回true，否则就会返回false
  //同时返回的数据也是实现了Iterable的接口,注意是Iterable而不一定是List
  var testMap1 = testList6.map((item) => item.toString().length == 2);
  print("
  testMap1:${testMap1}");
  print("testMap1: ${testMap1.runtimeType} 
  ");

• 这个方法可以用，但是不知道具体的应用实例
  

  //这个方法可以用，但是不知道具体的应用实例
  //这个方法首先会传入列表的第一个和第二个数据，对这两个数据进行传入的函数操作，然后会将函数的返回值作为下一次操作的第一个参数
  print("${testList6}");
  var testReduce = testList6.reduce((value,element) => checkReduce(value.toString(), element.toString()));
  print("
  testReduce ${testReduce} type is ${testReduce.runtimeType}
  ");

• 跳过前面多少个元素，返回一个SubListIterable，和subList的操作相似
  

  //跳过前面多少个元素，返回一个SubListIterable，和subList的操作相似
  print(testList6);
  var testSkip = testList6.skip(2);
  print("
  testSkip: ${testSkip}, and type is ${testSkip.runtimeType}
  ");

• 跳过列表中满足条件的前面的元素，从第一个元素开始查找，一直查找到不满足条件的元素为止
  

  //跳过列表中满足条件的前面的元素，从第一个元素开始查找，一直查找到不满足条件的元素为止
  //条件由传入的函数参数决定
  testList6.insert(0, "呸呸呸");
  var testSkipWhile = testList6.skipWhile((item) => item.toString().length == 3);
  print("
  testSkipWhile:${testSkipWhile},and type is ${testSkipWhile.runtimeType}
  ");

• 注意Set为没有顺序且不可重复的列表，数据转换到set之后圆List中的重复的数据会被删掉
  

  //注意Set为没有顺序且不可重复的列表，数据转换到set之后圆List中的重复的数据会被删掉
  print(testList6);
  Set testSet1 = testList6.toSet();
  print("
  testSet1:${testSet1} and type is ${testSet1.runtimeType}
  ");

   原文地址：http://www.mamicode.com/info-detail-2714211.html