【Dart】003-基本数据类型

【Dart】003-基本数据类型

文章目录

• ​​【Dart】003-基本数据类型​​
• ​​一、布尔和数字​​

• ​​1、BMI 指数​​
• ​​2、整型与浮点型​​

• ​​代码示例​​
• ​​num 类型​​

• ​​3、数字的方法​​

• ​​二、字符串​​

• ​​1、字符串的定义​​

• ​​概述​​
• ​​代码示例​​
• ​​引号说明​​

• ​​2、字符串模板​​
• ​​3、字符串方法​​

• ​​字符数组​​
• ​​截取方法​​
• ​​去空格方法​​
• ​​大小写字母转换​​
• ​​判断开头、结尾、包含​​
• ​​替换与分割​​

• ​​三、聚合类型​​

• ​​1、List 列表​​

• ​​概述​​
• ​​基本示例​​
• ​​对列表常用操作​​

• ​​2、Set 集合​​

• ​​基本特征​​
• ​​基本示例​​
• ​​对集合常用操作​​

• ​​3、Map 映射​​

• ​​概述​​
• ​​基本示例​​
• ​​对映射的常用操作​​

• ​​4、三种聚合类型的关系​​

一、布尔和数字

​​Dart​​​ 中最基础类型只有 ​​bool​​​ 和 ​​num​​​ ，分别表示 ​​真假​​​ 和 ​​数字​​ 。

​​bool​​：true、false

​​num​​：整型 int 浮点型 double

1、BMI 指数

这里通过 ​​BMI​​​ 指数的例子介绍一下布尔和数字类型的使用。​​BMI​​​ 表示 ​​健康的指标​​​ ，公式是 ​​体重(kg)/身高(m)的平方​​​ 。在 ​​18.5 ~ 23.9​​ 之间，表示正常。

main() {
  // 数字类型：身高体重
  double result = bmi(height: 1.83 , weight: 78);
  // 布尔类型：是否正常
  bool normal = result >= 18.5 && result <= 23.9;
  print(normal); // true
}

double bmi({
  required double weight,
  required double height,
}) {
  return weight / (height * height);
}

2、整型与浮点型

代码示例

int count = 49; // 整型
double pi = 3.14; // 浮点型

num 类型

既可以表示整数，也可以表示小数。

main() {
  num age = 26;
  num tall = 1.83;
  print("Hello Dart! I'm $age years old and $tall meters tall.");
  // Hello Dart! I'm 26 years old and 1.83 meters tall.
}

使用 ​​runtimeType​​​ 查看某个变量的运行时类型，可以说 ​​num​​ 会根据赋值状况，自动转换为对应的数字类型（类型推断）。

也可以理解为“父类”，​​number​​​ 类型是 ​​int​​​ 和 ​​double​​ 的父类。

main() {
  num age = 26;
  num tall = 1.83;
  print("age:${age.runtimeType}, tall:${tall.runtimeType}");
  // age:int, tall:double
}

3、数字的方法

这里列举一些 ​​num​​​ 常用的方法，其中 ​​num​​​ 的方法 ​​double​​​ 和 ​​int​​ 对象都可以使用。

闲聊*：看起来还真像“父类”；

main() {
  num b = 3.28;
  b.abs();    // 绝对值 : 3.28
  b.ceil();     // 向上取整: 4
  b.floor();    // 向下取整: 3
  b.round();    // 四舍五入取整: 3
  b.truncate();   // 去除小数部位取整: 3
  String v = b.toStringAsFixed(1); // 四舍五入，保留几位小数，返回字符串: 3.3
  print(v); // 3.3
}

在 ​​double​​​ 和 ​​int​​​ 中，定义了 ​​parse​​ 方法用于通过解析数据获得数字

main() {
  double result1 = double.parse("3.3");
  int result2 = int.parse("10");
  print(result1.runtimeType); // double
  print(result2.runtimeType); // int
}

对于 ​​int​​​ 类型来说，有一些关于 ​​进制​​​ 的方法，通过 ​​toRadixString​​ 可以把整型转化为其他进制，以字符串形式输出。

main() {
  int a = 2022;
  print(a.toRadixString(2)); // 11111100110
  print(a.toRadixString(8)); // 3746
  print(a.toRadixString(16)); // 7e6
  print(a.toRadixString(32)); // 1v6
}

另外在 ​​int​​​ 解析字符串时，也可以指定字符串的进制。比如 ​​16​​​ 进制中，允许出现 ​​0~9​​​ 和 ​​a~f​​​ 。以此类推，对于 ​​36​​ 进制，可以包含数字和字母。那么找出你喜欢单词 36 进制的幸运数字吧。

有点意思：仅做摘录，不再演示！

int value = int.parse('7e6',radix: 16);
print(value); // 2022

int value1 = int.parse('toly',radix: 36);
print(value1); // 1384918

二、字符串

1、字符串的定义

概述

​​Dart​​​ 中字符串的定义语法还是非常丰富的，如下所示：支持 ​​单引号​​​ 、​​双引号​​​ 、​​三单引号​​​、​​三双引号​​ 。

代码示例

String a = 'hello, toly';
String b = "hello, toly";
String c = '''hello, toly''';
String d = """hello, toly""";

引号说明

• 比较推荐使用 ​​单引号​​ ；
• 多个引号可以相互嵌套：同种引号嵌套需要加转义字符 ​​\​​ ；

2、字符串模板

一般情况下可以通过 ​​+​​​ 号来拼接字符串的内容，但如果通过多个变量来拼接字符串，使用 ​​+​​ 就非常麻烦。

​​Dart​​ 中提供的字符串模板，在字符串中通过 ​​${变量}​​​ 插入变量，方便拼接。另外如果​​{}​​​ 中只有变量名称，可以省略 ​​{} ​​​。如下的 ​​$addr​​ ：

main() {
  String name = '訾博';
  print('my name is ${name}');
  print('my name is $name');
  // my name is 訾博
  // my name is 訾博
}

3、字符串方法

字符数组

字符串本身相当于若干字符组成的聚合对象（数组），可以通过 ​​[]​​​ 来访问第几个字符，一般称​​“第几个”​​​为 ​​索引​​ 。

好直接啊！​​java​​​ 还需要转成数组，​​dart​​ 直接当数组用！

main() {
  String name = '訾博';
  print(name[0]);
  print(name[1]);
  // 訾
  // 博
}

截取方法

​​substring​​​ 方法截取字符串。其中有两个入参，分别表示 ​​起始索引​​​ 和 ​​结束索引​​。注意，包含起始字符，不包含结束字符。

main() {
  String name = '我的名字是訾博';
  print(name.substring(2, 4)); // 名字
}

去空格方法

字符串的 ​​trim​​​ 方法用于去除首尾 ​​空格符​​​ ，另外 ​​trimLeft​​​ 只去除开头的空格； ​​trimRight​​ 只去除末尾的空格

main() {
  String name = ' 我的名字 是訾博 ';
  // 1. 去除字符串左侧端的空格
  print(name.trimLeft());
  // 2. 去除字符串右侧端的空格
  print(name.trimRight());
  // 3. 去除字符串两端的空格
  print(name.trim());
  // 我的名字 是訾博 
  //  我的名字 是訾博
  // 我的名字 是訾博
}

大小写字母转换

字符串的 ​​toUpperCase​​​ 方法用于把所有字母变成大写字母；​​toLowerCase​​ 方法把所有字母变成小写字母

main() {
  String name = '訾博（ZiBo）';
  // 1. 转大写
  print(name.toUpperCase());
  // 2. 转小写
  print(name.toLowerCase());
  // 訾博（ZIBO）
  // 訾博（zibo）
}

判断开头、结尾、包含

字符串有三个返回 ​​bool​​​ 类型的方法，如下分别校验 ​​是否以XXX开头​​​ 、​​是否以XXX结尾​​​、 ​​是否包含 XXX​​

main() {
  String name = '訾博（ZiBo）';
  // 1. 判断开头
  print(name.startsWith('訾'));
  // 2. 判断结尾
  print(name.endsWith('博'));
  // 3. 判断包含
  print(name.contains('訾博'));
  // true
  // false
  // true
}

替换与分割

通过 ​​replaceAll​​​ 和 ​​split​​ 方法可以对字符串进行替换和分割操作

main() {
  String name = '訾博（ZiBo）,訾博（ZiBo）,訾博（ZiBo）';
  // 1、替换
  print(name.replaceAll(',', '，'));
  // 2、分割
  List<String> list = name.split('，');
  print(list);
  // 3、正则表达式，匹配字母
  RegExp exp = new RegExp(r'[a-zA-Z]');
  print(name.replaceAll(exp, ''));
  // 訾博（ZiBo），訾博（ZiBo），訾博（ZiBo）
  // [訾博（ZiBo）,訾博（ZiBo）,訾博（ZiBo）]
  // 訾博（）,訾博（）,訾博（）
}

三、聚合类型

比如一个班级中有若干个学生；一幅扑克里有 ​​52​​​ 张牌；一本英文字典里记录着众多单词和释义信息的对应关系。对于这些拥有多种元素的聚合体，一般编程语言中会有内置类型。 ​​Dart​​​ 中提供了 ​​List​​​ 、​​Map​​​ 、​​Set​​​ 分别用于表示 ​​列表​​​ 、​​映射​​​ 、​​集合​​ 类型。

1、List 列表

概述

​​Dart​​​ 中通过 ​​List​​​ 来维护多个元素，列表用 ​​[]​​​ 进行定义，通过 ​​,​​ 来分隔元素。

基本示例

main() {
  List<String> name = ['刘备', '关羽', '张飞'];
  print(name); // [刘备, 关羽, 张飞]
}

对列表常用操作

main() {
  List<String> list = ['刘备', '关羽', '张飞'];
  List<String> list2 = ['曹操', '刘备', '孙权'];
  // 1、for 循环
  for (int i = 0; i < list.length; i++) {
    print(list[i]);
  }
  // 2、增加元素
  list.add('赵云');
  print(list);
  // 3、增加多个元素
  list.addAll(list2);
  print(list);
  // 4、插入元素
  list.insert(1, '诸葛亮');
  print(list);
  // 5、删除元素
  list.remove('张飞');
  print(list);
  // 6、删除指定位置的元素
  list.removeAt(1);
  print(list);
  // 7、修改元素
  list[0] = '曹操';
  print(list);
  // 8、判断是否包含某个元素
  print(list.contains('刘备'));
  // 9、判断是否为空
  print(list.isEmpty);
  // 10、判断是否不为空
  print(list.isNotEmpty);
  // 11、获取元素的个数
  print(list.length);
  // 12、获取指定位置的元素
  print(list[0]);
  // 13、删除所有元素
  list.clear();
  print(list);
  // 刘备
  // 关羽
  // 张飞
  // [刘备, 关羽, 张飞, 赵云]
  // [刘备, 关羽, 张飞, 赵云, 曹操, 刘备, 孙权]
  // [刘备, 诸葛亮, 关羽, 张飞, 赵云, 曹操, 刘备, 孙权]
  // [刘备, 诸葛亮, 关羽, 赵云, 曹操, 刘备, 孙权]
  // [刘备, 关羽, 赵云, 曹操, 刘备, 孙权]
  // [曹操, 关羽, 赵云, 曹操, 刘备, 孙权]
  // true
  // false
  // true
  // 6
  // 曹操
  // []
}

2、Set 集合

基本特征

• ​​Dart​​​ 中集合用 ​​{}​​​ 进行定义，通过 ​​,​​ 来分隔元素。
• ​​Set​​​ 和数学中 ​​集合​​​的概念一样，可容纳若干个元素，且 ​​不包含相同元素​​。
• ​​Set​​​ 是无序的，没有索引的概念，所以无法通过 ​​[]​​ 对元素进行访问和修改。
• 而 ​​List​​ 允许包含相同元素，和索引访问，这就是两者最大的区别。

基本示例

main() {
  Set<String> set = { '刘备', '关羽', '张飞' };
  print(set); // {刘备, 关羽, 张飞}
}

对集合常用操作

main() {
  Set<String> set = {'刘备', '关羽', '张飞'};
  print(set); // {刘备, 关羽, 张飞}
  // 1、添加元素
  set.add('赵云');
  print(set); // {刘备, 关羽, 张飞, 赵云}
  // 1.1 添加多个元素
  set.addAll({'马超', '黄忠'});
  print(set); // {刘备, 关羽, 张飞, 赵云, 马超, 黄忠}
  // 2、删除元素
  set.remove('张飞');
  print(set); // {刘备, 关羽, 赵云}
  // 2.1 删除多个元素
  set.removeAll({'刘备', '关羽'});
  print(set); // {赵云}
  // 3、判断元素是否存在
  print(set.contains('赵云')); // true
  print(set.contains('张飞')); // false
  // 4、获取元素个数
  print(set.length); // 3
  // 5、遍历元素
  set.forEach((element) {
    print(element);
  });
  // 赵云
  // 马超
  // 黄忠
  // 6、转换为List
  List<String> list = set.toList();
  print(list); // [赵云, 马超, 黄忠]
  // 7、交集
  Set<String> set1 = {'赵云', '马超', '黄忠'};
  Set<String> set2 = {'赵云', '马超', '黄忠', '张飞'};
  print(set1.intersection(set2)); // {赵云, 马超, 黄忠}
  // 8、并集
  print(set1.union(set2)); // {赵云, 马超, 黄忠, 张飞}
  // 9、差集
  print(set1.difference(set2)); // {}
  print(set2.difference(set1)); // {张飞}
  // 10、查找元素
  print(set1.lookup('赵云')); // 赵云
  print(set1.lookup('张飞')); // null
  // 11、判断是否为空
  print(set1.isEmpty); // false
  print(set1.isNotEmpty); // true
  // 12、清空
  set1.clear();
  print(set1); // {}
}

3、Map 映射

概述

把一个事物，与另一个事物相对应，这本身就是 ​​映射​​ 。映射记录的是两个事物之间的联系。

基本示例

main() {
  Map<String, String> map = {
    'name': '訾博',
    'age': '26',
  };
  print(map); // {name: 訾博, age: 26}
}

对映射的常用操作

main() {
  Map<String, String> map = {
    'name': '訾博',
    'age': '26',
  };
  print(map); // {name: 訾博, age: 26}
  // 1、遍历 map
  map.forEach((key, value) {
    print('$key: $value');
  });
  // 2、获取所有的 key
  print(map.keys); // (name, age)
  // 3、获取所有的 value
  print(map.values); // (訾博, 26)
  // 4、判断是否包含某个 key
  print(map.containsKey('name')); // true
  // 5、判断是否包含某个 value
  print(map.containsValue('訾博')); // true
  // 6、获取长度
  print(map.length); // 2
  // 7、判断是否为空
  print(map.isEmpty); // false
  // 8、判断是否不为空
  print(map.isNotEmpty); // true
  // 9、删除某个 key
  map.remove('name');
  print(map); // {age: 26}
  // 10、清空 map
  map.clear();
  print(map); // {}
  // 11、添加元素
  map['name'] = '訾博';
  map['age'] = '26';
  print(map); // {name: 訾博, age: 26}
  // 12、获取某个 key 的 value
  print(map['name']); // 訾博
  // 13、获取某个 key 的 value，如果不存在则返回默认值
  print(map.putIfAbsent('name', () => '訾博')); // 訾博
  // 14、修改某个 key 的 value
  map.update('name', (value) => '訾博');
  print(map); // {name: 訾博, age: 26}
  // 15、修改某个 key 的 value，如果不存在则添加
  map.update('name', (value) => '訾博', ifAbsent: () => '訾博');
  print(map); // {name: 訾博, age: 26}
  // 16、删除某个 key value 对
  map.remove('name');
  print(map); // {age: 26}
}

4、三种聚合类型的关系

首先 ​​List​​​ 和 ​​Set​​​ 之间可以相互转化。我们前面知道，​​Set​​​ 中的元素是不重复的，所以如果 ​​List​​​ 中有重复的元素，通过 ​​toSet​​​ 方法转化为 ​​Set​​​ 之后，可以去除重复元素，再把 ​​Set​​​ 通过 ​​toList​​​ 转化为 ​​List​​​ ，就可以达到 ​​去重​​ 的需求。

其次，​​List​​​ 通过 ​​asMap​​​ 方法可以返回一个 ​​Map​​ 对象。其中键是索引，值是元素值。

然后，通过 ​​Map.fromIterables​​ 方法，可以根据两个可迭代对象创建映射对象，前者是 ​​key​​​ ，后者是 ​​value​​​ 。其中 ​​List​​​ 和 ​​Set​​ 都是可迭代对象，可以作为入参。

最后，​​Map​​​ 对象可以通过 ​​keys​​​ 和 ​​values​​ 获取可迭代对象，再通过 ​​toList​​​ 和 ​​toSet​​​ 就可以获得 ​​List​​​ 和 ​​Set​​ 对象。