【Dart】003-基本数据类型

迈不过友情╰ 2023-09-23 14:52 67阅读 0赞

# 【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` 对象。