Flutter学习4 - Dart数据类型

1、基本数据类型 num、int、double

（1）常用数据类型

• num类型，是数字类型的父类型，有两个子类 int 和 double

通过在函数名前加下划线，可以将函数变成私有函数，私有函数只能在当前文件中调用

//常用数据类型
void main() {
  _numType();
}

//返回值为 void 的函数，可省略 void
_numType() {
  //num类型，是数字类型的父类型，有两个子类  int  和  double
  num num1 = -1.0; //double
  num num2 = 2; //int
  int num3 = 3; //只能是整数，不可为 int 类型赋值 浮点数
  double num4 = 1.666; //双精度浮点数

  print("num1: $num1   num2: $num2   num3: $num3   num4: $num4");
}

//num1: -1.0   num2: 2   num3: 3   num4: 1.666
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（2）数据类型常用方法及类型转换

• 绝对值函数 abs() 等

void main() {
  _numType();
}

_numType() {
  num num1 = -1.0;
   //绝对值
  print("num1: $num1   num1.abs(): ${num1.abs()}");
}

//num1: -1.0   num1.abs(): 1.0
1
2
3
4
5
6
7
8
9
10
11

• 类型转换 toInt() 等

void main() {
  _numType();
}

_numType() {
  num num1 = -1.0;

  //数据类型转换
  print("num1: $num1   toInt(): ${num1.toInt()}");
}

//num1: -1.0   toInt(): -1
1
2
3
4
5
6
7
8
9
10
11
12

2、字符串 String

（1）字符串定义

• 定义字符串，单引号/双引号 均可

void main() {
  _stringType();
}

//字符串
_stringType() {
  //定义字符串，单引号/双引号 均可
  String str1 = '窗前明月光', str2 = "疑是地上霜";
  String str3 = '$str1，$str2';
  print(str3);
}

//窗前明月光，疑是地上霜
1
2
3
4
5
6
7
8
9
10
11
12
13

（2）字符串常用方法

• 截断字符串 substring()
• 查找子字符串位置 indexOf()
• 对比字符串 compareTo()
• ···

void main() {
  _stringType();
}

//字符串
_stringType() {
  //定义字符串，单引号/双引号 均可
  String str1 = '窗前明月光，疑是地上霜';
  //截断字符串 substring
  print(str1.substring(1, 5)); //前明月光
  //查找子字符串在父字符串˙中位置
  print(str1.indexOf("明月")); //2

  //对比两个字符串
  String str2 = 'abc', str3 = 'gdf';
  print(str2.compareTo(str3)); //-1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3、布尔类型 bool

• Dart 是强 bool 类型检查的，只有 bool 类型的值是 true，才被认为是 true

void main() {
  _boolType();
}

// Dart 是强 bool 类型检查的，只有 bool 类型的值是 true，才被认为是 true
_boolType() {
  bool b1 = true, b2 = false;
  print("b1: $b1");
  print("b2: $b2");
  print("b1 || b2: ${b1 || b2}");
  print("b1 && b2: ${b1 && b2}");
}

//b1: true
//b2: false
//b1 || b2: true
//b1 && b2: false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4、集合

4.1、集合 List

（1）List 的定义

• 初始化 List：[]

void main() {
  _listType();
}

_listType() {
  List list1 = [1, 2, 3, "Flutter", true];
  print("list1: $list1");

  List<int> list2 = [];
  // list2 = list1;  报错  List<dynamic> 类型无法转换成 List<int>
  list2.add(9);
  list2.add(8);
  list2.add(7);
  print("list2: $list2");

  List list3 = [];
  list3.add("Hello");
  list3.addAll(list1);
  print("list3: $list3");
}

//list1: [1, 2, 3, Flutter, true]
//list2: [9, 8, 7]
//list3: [Hello, 1, 2, 3, Flutter, true]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• List 生成函数：grnerate

void main() {
  _listType();
}

_listType() {
  List list1 = List.generate(5, (index) => index * 3);
  print("list1: $list1");

  List list2 = List.generate(3, (index) => 'index: $index');
  print("list2: $list2");
}

//list1: [0, 3, 6, 9, 12]
//list2: [index: 0, index: 1, index: 2]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（2）List 常用方法

• 遍历、插入、移除、截取、查找等方法使用

void main() {
  _listType();
}

_listType() {
  List list = List.generate(5, (index) => index * 3);
  print("list: $list"); //list: [0, 3, 6, 9, 12]

  //遍历集合
  print("--------------- 遍历 for ---------------");
  for (int i = 0; i < list.length; i++) {
    print("$i: ${list[i]}");
  }

  print("--------------- 遍历 in ---------------");
  for (var e in list) {
    print(e);
  }

  print("--------------- 遍历 forEach ---------------");
  list.forEach((element) {
    print(element);
  });

  //插入
  list.insert(0, 'start');
  print(list); //[start, 0, 3, 6, 9, 12]

  //移出
  list.removeAt(1);
  print(list); //[start, 3, 6, 9, 12]
  list.remove('start');
  print(list); //[start, 3, 6, 9, 12]

  //截取
  List list2 = list.sublist(0, 2);
  print("list: $list"); //list: [3, 6, 9, 12]
  print("list2: $list2"); //list2: [3, 6]

  //查找
  int index = list.indexOf(9);
  print("index: $index");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

4.2、集合 Map

• Map 是 key-value 键值对
• key 和 value 可以是任意类型

（1）Map 定义

void main() {
  _mapType();
}

_mapType() {
  //Map 初始化
  Map map1 = {'xiaolan': '小蓝', 1: '小白', 1.2: true};
  print(map1); //{xiaolan: 小蓝, 1: 小白, 1.2: true}
  print(map1[1]); //小白

  Map map2 = {};
  map2[1] = true;
  map2['abc'] = 1.4;
  print(map2); //{1: true, abc: 1.4}

  Map<String, int> map3 = {};
  map3['leon'] = 18;
  map3['alice'] = 19;
  print(map3); //{leon: 18, alice: 19}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（2）Map 常用方法

• 遍历
• 移除
• 判断是否包含

void main() {
  _mapType();
}

_mapType() {
  Map map = {'小蓝': 2, '小白': 1};
  print(map); //{{小蓝: 2, 小白: 1}

  // Map遍历
  map.forEach((key, value) {
    print("key: $key, value: $value");
  });
  //key: 小蓝, value: 2
  // key: 小白, value: 1

  //通过遍历生成 Map
  Map map2 = map.map((key, value) {
    return MapEntry(key, value + 1);
  });
  print(map2); //{小蓝: 3, 小白: 2}

  //遍历 keys
  for (var key in map2.keys) {
    print("key: $key, value: ${map2[key]}");
  }
  //key: 小蓝, value: 3
  // key: 小白, value: 2

  //遍历 values
  for (var value in map2.values) {
    print("value: $value");
  }
  //value: 3
  // value: 2

  //移除元素
  map2.remove('小白');
  print(map2); //{小蓝: 3}

  //是否包含元素
  print("小白还在吗？  ${map2.containsKey('小白')}"); //小白还在吗？  false
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

5、补充：dynamic、var、Object

（1）动态类型 dynamic

• dynamic 是所有 Dart 对象的基础类型，在大多数情况下，通常不直接使用它

• 当我们不给泛型类型指定一个类型时，系统就会将其指定为动态类型，如 List list = [];

• 不建议使用 dynamic 类型，因为通过它定义的变量会关闭静态类型检查，有些异常只有运行时才能 carsh 出来

• 崩溃报错

void main() {
  _dynamicType();
}

_dynamicType() {
  dynamic x = '111';
  x.foo(); //报错崩溃
  //静态类型检查时不会报错
  //但运行时报错 NoSuchMethodError: Class 'String' has no instance method 'foo'.
  //因为 String 没有 foo() 这个方法，但是因为关闭了检查，只会在运行时报错
}
1
2
3
4
5
6
7
8
9
10
11

静态变量检查时，不报错

运行时，会报 crash

• 查看运行时类型

void main() {
  _dynamicType();
}

_dynamicType() {
  dynamic x = '111';
  print("x 的运行时类型：${x.runtimeType}"); //x 的运行时类型：String
  x = 123;
  print("x 的运行时类型：${x.runtimeType}"); //x 的运行时类型：int
}
1
2
3
4
5
6
7
8
9
10

（2）关键字 var

• var 是一个关键字，定义变量时不关心变量类型是什么，系统会自动推断类型 runtimeType
• 类似 Kotlin 中的 var
• var 声明的变量，静态类型检查时会检查类型，但动态类型 dynamic 不会检查

void main() {
  _var();
}

_var() {
  var a = 'AAA';
  print("a 的运行时类型：${a.runtimeType}"); //a 的运行时类型：String

  a = 11; //静态类型检查时会报错，因为已经推断出是 String 类型，不能在赋值 int
  a.foo(); //静态类型检查时会报错
}
1
2
3
4
5
6
7
8
9
10
11

（3）Object 类型

• Object 是 Dart对象的基类
• 当定义 Object o = ‘11’; 时，系统会认为 o 是个对象，可以调用 o 的 toString() 和 hashCode() 方法，因为 Object 提供了这些方法
• Object 声明的变量，静态类型检查时会检查类型

综上，Object 和 dynamic 的区别就在于静态类型的检查上

void main() {
  _objectType();
}

_objectType() {
  Object o1 = '11';
  print("o1运行时类型：${o1.runtimeType}"); //o1运行时类型：String
  o1 = 123;
  print("o1运行时类型：${o1.runtimeType}"); //1运行时类型：int

  o1.foo(); //静态类型检查时会报错
}
1
2
3
4
5
6
7
8
9
10
11
12