Dart 数据类型 - Set

Set 是一个无序的、元素唯一的集合，无法通过 Set[index] 的方式取值

声明方式

（1）、字面量：用大括号

（2）、构造函数：通过 Set() 创建一个空的集合，再往里面添加元素

  // 字面量
  var subjects = {'dart', 'flutter'};
  print(subjects); // {dart, flutter}

  Set<int> nums = <int>{1, 2, 3};
  print(nums); // {1, 2, 3}

  // 构造函数
  Set<String> fruits = new Set<String>();
  fruits.add('apple');
  fruits.add('banana');
  print(fruits); // {apple, banana}

 

属性

（1）、length：int，只读，返回集合内容的长度

（2）、isEmpty/isNotEmpty：bool，只读，判断集合是否为空/至少包含一个元素

（3）、first/last：E，只读，返回集合的第一/最后一个元素

（4）、single：E，只读，检查集合是否只有一个元素并返回该元素

  // length, first, last
  print(fruits.length); // 2
  print(fruits.first); // apple
  print(fruits.last); // banana

  // isEmpty, isNotEmpty
  print(fruits.isEmpty); // false
  print(fruits.isNotEmpty); // true

  // single
  var singleSet = {'unique'};
  print(singleSet.single); // unique

 

方法

（1）、toList({bool growable = true}) → List<E> ：把集合转成一个List

（2）、toSet() → Set<E> ：去掉重复的元素

（3）、add(E value) → bool ：添加一个元素

（4）、addAll(Iterable<E> elements) → void ：添加多个元素

（5）、contains(Object? value) → bool ：判断是否包含某个元素

（6）、remove(Object? value) → bool ：删除某一个元素

（7）、intersection(Set<Object?> other) → Set<E> ：返回两个集合的交集

（8）、union(Set<E> other) → Set<E> ：返回两个集合的并集

（9）、difference(Set<Object?> other) → Set<E> ：返回两个集合的差集，调用other的contains方法，返回不包含在该集合中的元素

（10）、clear() → void ：清空一个集合

  // toList()
  List fruitsList = fruits.toList(growable: true);
  fruitsList.add('pear');
  print(fruitsList); // [apple, banana, pear]

  // toSet()
  List<String> duplicateList = <String>['rogers', 'tony', 'roger', 'rogers'];
  Set result = duplicateList.toSet();
  print(result); // {rogers, tony, roger}

  // add()
  bool isAddOk = fruits.add('watermelon');
  print(isAddOk); // true
  print(fruits); // {apple, banana, watermelon}

  // addAll()
  fruits.addAll({'cherry', 'grape'});
  print(fruits); // {apple, banana, watermelon, cherry, grape}

  // contains()
  bool hasElement = fruits.contains('grape');
  print(hasElement); // true

  // remove()
  bool isRemoveOk = fruits.remove('watermelon');
  print(isRemoveOk); // true
  print(fruits); // {apple, banana, cherry, grape}

  const num1 = {1, 2, 3};
  const num2 = {3, 5, 7};

  // intersection()
  Set result1 = num1.intersection(num2);
  print(result1); // {3}

  // union()
  Set result2 = num1.union(num2);
  print(result2); // {1, 2, 3, 5, 7}

  // difference()
  Set result3 = num1.difference(num2);
  print(result3); // {1, 2}

  fruits.clear();
  print(fruits); // {}

 

遍历

（1）、forEach(void action(E element)) → void

（2）、map<T>(T toElement(E e)) → Iterable<T> ：返回一个新的可迭代对象

（3）、reduce(E combine(E value, E element)) → E ：用指定的方法对元素做连续操作

（4）、where(bool test(E element)) → Iterable<E> ：返回满足条件的可迭代对象

（5）、any(bool test(E element)) → bool ：至少存在一个满足条件的元素

（6）、elementAt(int index) → E ：返回指定位置的元素

（7）、every(bool test(E element)) → bool ：判断集合中是否所有元素都满足指定条件

（8）、expand<T>(Iterable<T> toElements(E element)) → Iterable<T> ：为集合的每个元素都执行指定的操作

（9）、firstWhere(bool test(E element), {E orElse()?}) → E ：返回第一个满足条件的元素

（10）、fold<T>(T initialValue, T combine(T previousValue, E element)) → T ：类似JS的reduce的累加器函数

（11）、join([String separator = ""]) → String ：返回一个按条件拼接好的字符串

  const letters = {'A', 'B', 'C'};
  // Set不可以通过[]获取元素
  for (int i = 0; i < letters.length; i += 1) {
    // print(letters[i]); // Error: The operator '[]' isn't defined for the class 'Set<String>'.
    print(letters.elementAt(i));
  }

  // forEach()
  letters.forEach((element) {
    print(element);
  });

  // map()
  final newLetters = letters.map((e) => '${e}D');
  print(newLetters); // (AD, BD, CD)
  print(newLetters.toSet()); // {AD, BD, CD}

  // reduce()
  final numbers = [10, 20, 30];
  final sum = numbers.reduce((value, element) => value + element);
  print(sum); // 60

  // where()
  final res = numbers.where((element) => element % 4 == 0);
  print(res); // (20)
  print(res.toSet()); // {20}

  // any()
  bool anyResult = numbers.any((element) => element % 4 == 0);
  print(anyResult); // true

  // elementAt()
  final element = numbers.elementAt(0);
  print(element); // 10
  // 访问下标越界的元素会报错
  // final notExist = numbers.elementAt(100);
  // print(notExist); // RangeError (index): Invalid value: Not in inclusive range

  // every()
  bool everyResult = numbers.every((element) => element % 4 == 0);
  print(everyResult); // false

  // expand()
  const set1 = {'dart', 'flutter'};
  final expandResult = set1.expand((element) => element.split(''));
  print(expandResult); // (d, a, r, t, f, l, u, t, t, e, r)

  // firstWhere()
  final set2 = {1, 3, 5, 7, 9};
  final firstElement = set2.firstWhere((element) => element > 2);
  print(firstElement); // 3

  // fold()
  Set<int> set3 = <int>{1, 2, 3, 4};
  int foldResult =
      set3.fold<int>(100, (previousValue, element) => previousValue + element);
  print(foldResult); // 110

  // join()
  String joinStr = set1.join('~');
  print(joinStr); // dart~flutter