Flutter 数据类型

关键字	是否可变	值何时确定	类型是否固定	常见用途
var	✔ 可变	运行时	✔ 第一次赋值后固定	普通变量
final	✖ 不可变	运行时确定一次	✔ 固定	运行时常量，如 DateTime.now()
const	✖ 不可变	编译期就必须确定	✔ 固定	编译期常量，如 1、"abc"
dynamic	✔ 可变	运行时	✖ 不固定	类型不确定、动态类型
late	✔ 可变	首次使用时 才初始化	✔ 固定	延迟初始化变量、避免一开始无法赋值

// --- var：可变变量，类型在第一次赋值后固定 ---
var age = 18;
age = 20;          // ✔ 可以修改
// age = "abc";    // ❌ 类型在第一次赋值后固定为 int


// --- final：运行时确定一次，不可重新赋值，但内部内容可变 ---
final now = DateTime.now();
// now = 123;      // ❌ 不允许重新赋值

final list1 = [1, 2, 3];
list1.add(4);       // ✔ 内部可变
// list1 = [5, 6]; // ❌ 不可重新赋值


// --- const：编译期常量，完全不可变，包括内部 ---
const PI = 3.14159;
// const time = DateTime.now(); // ❌ 编译期无法确定

const list2 = [1, 2, 3];
// list2.add(4);              // ❌ 内部也不可改


// --- dynamic：动态类型，类型不固定，可以任意修改 ---
dynamic x = 10;
x = "hello";   // ✔ 可变
x = true;      // ✔ 任意类型都行（不推荐滥用）

// dynamic = 完全动态类型，运行时决定，会降低类型安全


// --- late：延迟初始化，在“第一次使用时”才赋值 ---
late String name;
name = "Tom";   // ✔ 初始化（必须在使用前赋值）
print(name);    // 使用

// late + final：只允许赋值一次，但延迟到首次使用前
late final int number;
number = 100;   // ✔ 可以赋值一次

// late 的典型用途：
// - 类中需要等构造完成后再初始化
// - 避免某些变量一开始没有值
// - 提升性能，延迟大对象构建

🎯 Dart 基本数据类型（核心 6 个）

1. int（整数）

int a = 10;
int b = -3;

常用方法

a.isEven;         // 是否偶数
a.isOdd;          // 是否奇数
a.abs();          // 绝对值
a.toDouble();     // 转 double

---

2. double（小数）

double pi = 3.14159;

常用方法

pi.toInt();       // 转 int
pi.toStringAsFixed(2); // 保留两位小数

3. num（int + double 都能放）

num x = 10;
x = 10.5;

4. String（字符串）

String name = "Tom";
String s = 'Hello';

常用方法（非常常用）

name.length;         // 长度
name.contains("o");  // 包含
name.toUpperCase();  // 转大写
name.toLowerCase();  // 转小写
name.trim();         // 去空格
name.split(" ");     // 分割
"123".isEmpty;       // 是否空字符串

字符串拼接：

var msg = "Hello $name";
var msg2 = "Sum: ${1 + 2}";

5. bool（布尔）

bool isOk = true;
isOk = false;

6. List（列表 / 数组）

List list=[1，2，3，'集合']; //初始化时，添加元素 不使用泛型
List list4 = List.generate(3,(index)=>index * 2); // 构造函数生成

List<int> nums = [1, 2, 3];
var words = ["a", "b"];
var empty = <String>[];

常用方法

// 增删改查
nums.add(4);          // [1,2,3,4]
nums.addAll([5, 6]);  // [1,2,3,4,5,6]

// insert / insertAll（插入）
nums.insert(1, 10);          // 在索引 1 插入 10
nums.insertAll(2, [7, 8, 9]); // 从索引 2 开始插入多个


nums.remove(2);       // 删除值为 2 的元素
nums.removeAt(0);     // 删除下标 0
nums.removeLast();    // 删除最后一个

nums.clear();

// 访问、切片
nums.elementAt(2);

// sublist（切片）

var part = nums.sublist(1, 4); // 从 1 ~ 3

// first / last
nums.first;
nums.last;

//遍历
nums.forEach((n) => print(n));

// map（映射，返回 Iterable）
var doubled = nums.map((n) => n * 2).toList();

// where（筛选）
var even = nums.where((n) => n.isEven).toList();

// fold（累加/聚合）
var sum = nums.fold(0, (prev, n) => prev + n);

//reduce（类似 fold）
var sum = nums.reduce((a, b) => a + b);

// expand（扁平化）
var list = [[1,2], [3,4]];
var flat = list.expand((e) => e).toList(); // [1,2,3,4]

// 查找方法
nums.indexOf(3);
nums.lastIndexOf(3);

nums.contains(1); // true
nums.any((n) => n > 10);      // 是否有任意元素符合条件
nums.every((n) => n > 0);     // 是否所有元素符合条件

var v = nums.firstWhere((n) => n > 5, orElse: () => -1);

nums.take(2).toList();  // 前两个
nums.skip(3).toList();  // 跳过前三个

// 排序
nums.sort(); // 默认升序

// 自定义排序
nums.sort((a, b) => b - a); // 降序

// 复制 / 转换
var newList = nums.toList();

// join

nums.join(","); // "1,2,3"

// asMap（List 转 Map，key 为 index）
var map = nums.asMap(); // {0:1,1:2,...}

// 其他常用属性
nums.length;
nums.isEmpty;
nums.isNotEmpty;

小结表格

方法	作用
add / addAll	添加元素
insert / insertAll	插入元素
remove / removeAt / removeLast	删除
sublist	切片
where / map / expand	筛选、映射、展开
sort	排序
fold / reduce	聚合
indexOf / contains	查找
take / skip	分段取值
asMap	转 Map
join	拼接为字符串

---

不可变 List：

const fixed = [1, 2, 3];

Map（对象 / 字典）

Map<String, int> scores = {
  "Tom": 90,
  "Lucy": 85,
};

scores["Tom"];   // 90

// 设置值 / 新增键值对
scores["Kate"] = 100;
scores.addAll({"Mike": 88});

// 删除键值对
scores.remove("Tom");
scores.removeWhere((key, value) => value < 60); // 按条件删

// 判断与检查

scores.containsKey("Tom");      // 是否存在某个 key
scores.containsValue(90);       // 是否存在某个 value
scores.isEmpty;                 // 是否为空
scores.isNotEmpty;              // 是否不为空
scores.length;                  // key-value 数量

// 访问所有 key / value / entry
scores.keys;       // 所有 key
scores.values;     // 所有 value
scores.entries;    // 键值对 Entry

// 示例（遍历 Entry）
for (var entry in scores.entries) {
  print("${entry.key} : ${entry.value}");
}
scores.forEach((key, value) {
  print("$key => $value");
});

// 合并 / 拷贝
scores.addAll({"AAA": 1, "BBB": 2});

var updated = scores.map((key, value) {
  return MapEntry(key, value + 5);
});

// 转换方法
var keyList = scores.keys.toList();
var valueList = scores.values.toList();

// entries 转 List<MapEntry>
var e = scores.entries.toList();

// putIfAbsent（不存在时才添加）
scores.putIfAbsent("John", () => 99);

// update（存在时修改值）
scores.update("Tom", (value) => value + 5);

// updateAll（批量更新）
scores.updateAll((key, value) => value + 1);

// 创建一个 Map 副本
var copy = Map.from(scores);
var deepCopy = Map.of(scores);

// 合并多个 Map
var merged = {...scores, ...{"A": 1, "B": 2}};

// 转字符串
scores.toString();  // "{Tom: 90, Lucy: 85}"

小结表格

方法	作用
[] / []=	获取/设置值
addAll	合并 Map
remove / removeWhere	删除
containsKey / containsValue	查找
keys / values / entries	获取 key、value、Entry
forEach	遍历
putIfAbsent	不存在时新增
update / updateAll	更新
map	转换成新 Map
Map.from / Map.of	复制
扩展运算符 {...a, ...b}	合并 Map

8. Set（集合：不能重复）

var s = {1, 2, 3};
s.add(3); // 加不进去，已存在

常用方法

s.contains(2);
s.remove(1);
s.length;

🧮 类型总结一句话

类型	作用
int	整数
double	小数
num	int + double
String	字符串
bool	布尔
List	数组
Map	对象
Set	不重复集合

🔥 Bonus：类型推断

Dart 通常会自动推断类型：

var x = 10;       // int
var y = "hello";  // String
var z = [1, 2, 3]; // List<int>