Dart入门—集合类型

Dart核心库提供了List（列表）、Map（映射）、Set（集）三种集合类型

列表（List）

固定长度的列表，一旦定义就无法改变长度

    List<int> fixedLengthList = new List(5);
    fixedLengthList[0] = 87;
    print(fixedLengthList);
    print(fixedLengthList[0]);

可改变长度的列表，可以根据需要改变长度

    List<int> growableList = [1, 2];
    print(growableList);

    growableList.length = 0;
    print(growableList);

    growableList.add(499);
    print(growableList);

    growableList[0] = 87;
    print(growableList);

几种构造函数

List([int length])

    // 创建固定长度的列表
    List fixedLengthList = new List(3);
    print(fixedLengthList.length);

    // 创建可改变长度的列表
    List growableListA = new List();
    print(growableListA.length);
    growableListA.length = 3;
    print(growableListA.length);

    // 创建可在固定范围内改变长度的列表
    List growableListB = new List()..length = 500;

List.unmodifiable(Iterable elements)

    // 创建包含所有元素的固定长度列表
    List fixedLengthListB = new List.unmodifiable([1, 2, 3]);
    print(fixedLengthListB.length);

List.from(Iterable elements, {bool growable: true})

    // 创建包含所有元素的可改变长度列表
    List growableListC = new List.from([1, 2, 3]);
    print(growableListC.length);
    growableListC.add(4);
    print(growableListC.length);

List.filled(int length, E fill, {bool growable: false})

    // 为所有元素统一赋值
    List fixedLengthList = new List<int>.filled(3, 0);
    print(fixedLengthList);

List.generate(int length, E generator(int index), {bool growable: true})

    // 用生成器给所有元素赋初始值
    List fixedLengthList = new List<int>.generate(4, (int index) {
        return index * index;
    });
    print(fixedLengthList);

所有属性

    List fixedLengthList = new List<int>.generate(4, (int index) {
        return index * index;
    });
    // 返回第一个元素
    print(fixedLengthList.first);
    // 返回最后一个元素
    print(fixedLengthList.last);
    // 返回列表的哈希码
    print(fixedLengthList.hashCode);
    // 列表是否为空
    print(fixedLengthList.isEmpty);
    // 列表是否不为空
    print(fixedLengthList.isNotEmpty);
    // 返回一个新的迭代器
    print(fixedLengthList.iterator);
    // 列表中多少个元素
    print(fixedLengthList.length);
    // 返回相反顺序的列表
    print(fixedLengthList.reversed);
    // 返回对象运行时的类型
    print(fixedLengthList.runtimeType);
    // 列表是否只有一个元素，则否报错
    print(fixedLengthList.single);

常用方法

返回多种类型的输出

    List growableList = new List.from([1, 2, 3]);
    // 返回列表的字符串表示
    print(growableList.toString());
    // 返回列表的集表示
    print(growableList.toSet());
    // 返回列表的列表表示
    print(growableList.toList());
    // 用指定字符连接列表元素
    print(growableList.join(","));

给列表增加元素

    List growableList = new List();
    // 增加一个元素到列表末尾
    growableList.add(10);
    print(growableList);
    // 增加一个元素到指定下标
    growableList.insert(1, 20);
    print(growableList);
    // 增加一个列表到列表末尾
    growableList.addAll([30, 60]);
    print(growableList);
    // 增加一个列表到指定下标
    growableList.insertAll(3, [40, 50]);
    print(growableList);

各种删除操作的方法

    List growableList = new List.from([1, 2, 3, 3, 3, 4]);
    // 移除列表中匹配的第一个元素
    growableList.remove(3);
    print(growableList);
    // 移除列表中第几个元素
    growableList.removeAt(0);
    print(growableList);
    // 移除列表中最后一个元素
    growableList.removeLast();
    print(growableList);
    // 移除列表的所有元素
    growableList.clear();
    print(growableList);

    List<int> listB = [1, 2, 3, 4, 5];
    // 移除开始下标（不包括）至结束下标（包括）内的元素
    listB.removeRange(1, 4);
    print(listB);

    List<int> listA = [1, 2, 3, 4, 5];
    // 移除并替换开始下标（不包括）至结束下标（包括）内的元素
    listA.replaceRange(1, 4, [6, 7]);
    print(listA);

    List<String> numbersA = [‘one‘, ‘two‘, ‘three‘, ‘four‘];
    /*  移除所有满足条件的元素，此为Dart的一种速写语法
        numbersA.removeWhere((item) => item.length == 3);   */
    numbersA.removeWhere((item){
        return item.length == 3;
    });
    print(numbersA);

    List<String> numbersB = [‘one‘, ‘two‘, ‘three‘, ‘four‘];
    /*  移除所有不满足条件的元素，此为Dart的一种速写语法
        numbersB.retainWhere((item) => item.length == 3);   */
    numbersB.retainWhere((item){
        return item.length == 3;
    });
    print(numbersB);

按顺序迭代列表

    List<String> names = ["Alice", "Daphne", "Elizabeth", "Joanna"];
    names.forEach((name){
        print(name);
    });

各种查询输出方法

    List<String> names = [‘Abbey‘, ‘Fallon‘, ‘Xenia‘, ‘Callie‘, ‘Callie‘];
    // 列表中是否包含指定元素
    print(names.contains(‘Fallon‘));
    // 返回列表中的第几个元素
    print(names.elementAt(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));

对列表元素做一些改动

    List<String> listA = [‘a‘, ‘b‘, ‘c‘];
    // 从第几个元素开始覆盖原列表
    listA.setAll(1, [‘bee‘, ‘sea‘]);
    print(listA);

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

    List<int> listC = [1, 2, 3, 4, 5];
    // 对列表进行顺序排序
    listC.sort();
    print(listC);

映射（Map）

映射也就是键值对，每个键都有与之相关联的一个值

几种构造函数

Map()

    Map<String, int> map = {"a":1, "b":2, "c":3};
    print(map["a"]);

Map.fromIterable(Iterable iterable, {K key(element), V value(element)})

    List<int> list = [1, 2, 3];
    // 以下代码用到了速写语法，后面会详细讲解
    Map<String, int> map = new Map.fromIterable(list,
        key: (item) => item.toString(),
        value: (item) => item * item);
    // 1 + 4 = 5
    print(map[‘1‘] + map[‘2‘]);
    // 9 - 4 = 5
    print(map[‘3‘] - map[‘2‘]);

Map.fromIterables(Iterable keys, Iterable values)

    List<String> letters = [‘b‘, ‘c‘];
    List<String> words = [‘bad‘, ‘cat‘];
    Map<String, String> map = new Map.fromIterables(letters, words);
    // bad + cat = badcat
    print(map[‘b‘] + map[‘c‘]);

所有属性

    Map<String, int> map = {"a":1, "b":2, "c":3};
    // 返回映射的哈希码
    print(map.hashCode);
    // 映射上是否没有键值对
    print(map.isEmpty);
    // 映射上是否有键值对
    print(map.isNotEmpty);
    // 返回映射的所有键
    print(map.keys);
    // 返回映射的所有值
    print(map.values);
    // 返回映射上键值对的数目
    print(map.length);
    // 返回对象运行时的类型
    print(map.runtimeType);

常用方法

    Map<String, int> map = {"a":1, "b":2, "c":3};
    // 返回映射的字符串表示
    print(map.toString());
    // 按顺序迭代映射
    map.forEach((key, value){
        print(key + " : " + value.toString());
    });
    // 添加其他键值对到映射中
    map.addAll({"d":4, "e":5});
    // 映射是否包含指定键
    print(map.containsKey("d"));
    // 映射是否包含指定值
    print(map.containsValue(5));
    // 删除指定键值对
    map.remove("a");
    // 删除所有键值对
    map.clear();

    Map<String, int> scores = {‘Bob‘: 36};
    for (var key in [‘Bob‘, ‘Rohan‘, ‘Sophena‘]) {
        // 查找指定键，如果不存在就添加
        scores.putIfAbsent(key, () => key.length);
    }
    print(scores[‘Bob‘]);
    print(scores[‘Rohan‘]);
    print(scores[‘Sophena‘]);

集（Set）

集的每个对象只能出现一次，不能重复

    Set villains = new Set();
    villains.add(‘Joker‘);
    villains.addAll( [‘Lex Luther‘, ‘Voldemort‘] );
    print(villains);

所有属性

    Set villains = new Set.from([‘Joker‘, ‘Lex Luther‘, ‘Voldemort‘]);
    // 返回第一个元素
    print(villains.first);
    // 返回最后一个元素
    print(villains.last);
    // 返回元素的数量
    print(villains.length);
    // 集只有一个元素就返回元素，否则异常
    //print(villains.single);
    // 集是否没有元素
    print(villains.isEmpty);
    // 集是否有元素
    print(villains.isNotEmpty);
    // 返回集的哈希码
    print(villains.hashCode);
    // 返回对象运行时的类型
    print(villains.runtimeType);
    // 返回集的可迭代对象
    print(villains.iterator);

常用方法

    Set villains = new Set.from(["A", "B", "C"]);
    // 添加一个值
    villains.add("D");
    print(villains);
    // 添加一些值
    villains.addAll(["E", "F"]);
    print(villains);
    // 以字符串输出集
    print(villains.toString());
    // 将集的值用指定字符连接，以字符串输出
    print(villains.join(","));
    // 集是否包含指定值
    print(villains.contains("C"));
    // 集是否包含一些值
    print(villains.containsAll(["E", "F"]));
    // 返回集的第几个值
    print(villains.elementAt(1));
    // 删除集的指定值，成功则返回true
    print(villains.remove("A"));
    // 删除集的一些值
    villains.removeAll(["B", "C"]);
    // 删除集的所有值
    villains.clear();