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
（2）数据类型常用方法及类型转换
- 绝对值函数 abs() 等
void main() {
_numType();
}
_numType() {
num num1 = -1.0;
//绝对值
print("num1: $num1 num1.abs(): ${num1.abs()}");
}
//num1: -1.0 num1.abs(): 1.0
- 类型转换 toInt() 等
void main() {
_numType();
}
_numType() {
num num1 = -1.0;
//数据类型转换
print("num1: $num1 toInt(): ${num1.toInt()}");
}
//num1: -1.0 toInt(): -1
2、字符串 String
（1）字符串定义
- 定义字符串，单引号/双引号 均可
void main() {
_stringType();
}
//字符串
_stringType() {
//定义字符串，单引号/双引号 均可
String str1 = '窗前明月光', str2 = "疑是地上霜";
String str3 = '$str1，$str2';
print(str3);
}
//窗前明月光，疑是地上霜
（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
}
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
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]
- 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]
（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");
}
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}
}
（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
}
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() 这个方法，但是因为关闭了检查，只会在运行时报错
}
静态变量检查时，不报错
运行时，会报 crash
- 查看运行时类型
void main() {
_dynamicType();
}
_dynamicType() {
dynamic x = '111';
print("x 的运行时类型：${x.runtimeType}"); //x 的运行时类型：String
x = 123;
print("x 的运行时类型：${x.runtimeType}"); //x 的运行时类型：int
}
（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(); //静态类型检查时会报错
}
（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(); //静态类型检查时会报错
}
