String 堆分配字符串
什么是 String
String 是 Rust 中可增长、可修改、拥有所有权的字符串类型。它的数据存储在堆上,由三部分组成:指向堆内存的指针、当前长度(已使用的字节数)和容量(已分配的字节数)。String 内部保证数据始终是合法的 UTF-8 编码。
和 &str 不同,String 拥有自己的数据,可以修改内容、追加文本、插入删除字符。当 String 变量离开作用域时,它持有的堆内存会自动释放。
fn main() {
// 创建 String
let mut s = String::from("Hello");
println!("{}", s); // Hello
// String 可以修改
s.push(','); // 追加一个字符
s.push_str(" World"); // 追加一段字符串
println!("{}", s); // Hello, World
// String 在内存中的结构
println!("长度:{} 字节", s.len()); // 12
println!("容量:{} 字节", s.capacity()); // 至少 12,可能更多
println!("String 变量大小:{} 字节", std::mem::size_of::<String>()); // 24
}创建 String 的方式
fn main() {
// 方式一:从字面量创建
let s1 = String::from("hello");
// 方式二:用 to_string() 方法
let s2 = "hello".to_string();
// 方式三:创建空字符串
let s3 = String::new();
// 方式四:指定初始容量(避免频繁扩容)
let s4 = String::with_capacity(100);
// 方式五:从字符迭代器收集
let s5: String = vec!['h', 'e', 'l', 'l', 'o'].into_iter().collect();
// 方式六:format! 宏拼接
let name = "Rust";
let version = 2026;
let s6 = format!("{} {}", name, version);
// 方式七:repeat 重复
let s7 = "ha".repeat(3); // "hahaha"
println!("{}, {}, '{}', '{}', {}, {}, {}", s1, s2, s3, s4, s5, s6, s7);
}修改 String
fn main() {
let mut s = String::from("Hello");
// 追加字符
s.push('!');
println!("push: {}", s); // Hello!
// 追加字符串切片
s.push_str(" World");
println!("push_str: {}", s); // Hello! World
// 插入字符(在指定字节位置)
s.insert(5, ',');
println!("insert: {}", s); // Hello,! World
// 插入字符串
s.insert_str(0, "Say: ");
println!("insert_str: {}", s); // Say: Hello,! World
// 替换(返回新 String)
let replaced = s.replace("Hello", "Hi");
println!("replace: {}", replaced);
// 截断到指定长度
let mut t = String::from("Hello, World!");
t.truncate(5);
println!("truncate: {}", t); // Hello
// 清空
t.clear();
println!("clear: '{}',长度:{}", t, t.len()); // '',长度:0
// 弹出最后一个字符
let mut u = String::from("hello");
let last = u.pop();
println!("pop: {:?},剩余:{}", last, u); // Some('o'),剩余:hell
// 删除指定字节位置的字符
let mut v = String::from("hello");
v.remove(0);
println!("remove: {}", v); // ello
}字符串拼接
fn main() {
// 方式一:+ 运算符
// 注意:左边是 String,右边是 &str
let s1 = String::from("Hello");
let s2 = String::from(" World");
let s3 = s1 + &s2; // s1 的所有权被移走了,s2 只是借用
// println!("{}", s1); // 编译错误:s1 已经被移动
println!("{}", s3); // Hello World
println!("{}", s2); // s2 仍然可用
// 方式二:format! 宏(推荐,不消耗任何变量的所有权)
let first = String::from("Hello");
let second = String::from("World");
let combined = format!("{}, {}!", first, second);
println!("{}", combined); // Hello, World!
println!("{}", first); // first 仍然可用
println!("{}", second); // second 仍然可用
// 方式三:push_str 逐步拼接
let mut result = String::new();
result.push_str("Hello");
result.push_str(", ");
result.push_str("World");
println!("{}", result); // Hello, World
// 方式四:join 从集合拼接
let words = vec!["Hello", "World", "Rust"];
let joined = words.join(", ");
println!("{}", joined); // Hello, World, Rust
}容量管理
fn main() {
// String 会在需要时自动扩容
let mut s = String::new();
println!("初始:长度={}, 容量={}", s.len(), s.capacity());
for i in 0..10 {
s.push_str("hello ");
println!("第 {} 次追加后:长度={}, 容量={}", i + 1, s.len(), s.capacity());
}
// 预分配容量避免频繁扩容
let mut efficient = String::with_capacity(60);
for _ in 0..10 {
efficient.push_str("hello ");
}
println!("\n预分配后:长度={}, 容量={}", efficient.len(), efficient.capacity());
// 收缩多余容量
efficient.shrink_to_fit();
println!("收缩后:长度={}, 容量={}", efficient.len(), efficient.capacity());
}基本示例
构建一个简单的 CSV 格式化器:
struct Record {
name: String,
age: u32,
city: String,
}
fn records_to_csv(records: &[Record]) -> String {
// 预估容量,减少扩容次数
let mut csv = String::with_capacity(records.len() * 50);
// 添加表头
csv.push_str("姓名,年龄,城市\n");
// 添加数据行
for record in records {
// 用 format! 拼接一行,再追加到结果中
let line = format!("{},{},{}\n", record.name, record.age, record.city);
csv.push_str(&line);
}
csv
}
fn main() {
let records = vec![
Record { name: String::from("张三"), age: 28, city: String::from("北京") },
Record { name: String::from("李四"), age: 32, city: String::from("上海") },
Record { name: String::from("王五"), age: 25, city: String::from("广州") },
];
let csv = records_to_csv(&records);
println!("{}", csv);
}常见问题
问题一:String 和 &str 之间怎么转换?
fn main() {
// &str -> String
let s1: String = "hello".to_string();
let s2: String = String::from("hello");
let s3: String = "hello".to_owned();
// String -> &str
let owned = String::from("hello");
let borrowed: &str = &owned; // 自动解引用
let borrowed2: &str = owned.as_str(); // 显式方法
let borrowed3: &str = &owned[..]; // 用切片语法
println!("{}, {}, {}", s1, s2, s3);
println!("{}, {}, {}", borrowed, borrowed2, borrowed3);
}问题二:+ 运算符拼接字符串为什么会消耗左边的 String?
+ 运算符实际上调用的是 fn add(self, s: &str) -> String,第一个参数是 self(按值传递),所以左边的 String 的所有权被移走了。这个设计是为了复用左边 String 的堆内存,避免额外的分配。如果不想消耗所有权,用 format! 宏。
问题三:String 能用索引访问字符吗?
不能直接用 s[0]。原因和 &str 一样——UTF-8 是变长编码,按字节索引可能切到字符中间。要访问第 n 个字符用 s.chars().nth(n)。
问题四:什么时候应该用 String,什么时候用 &str?
需要拥有数据时用 String(比如存在结构体字段中、从函数返回、需要修改内容)。只需要读取时用 &str(比如函数参数、临时处理)。
适用场景
- 构建和修改字符串:日志消息、SQL 查询、HTML 模板等
- 结构体的字符串字段:需要拥有数据的场景
- 函数返回值:从函数中返回新构建的字符串
- 从外部输入读取:文件内容、网络数据、用户输入
- 动态拼接:运行时根据条件组装字符串
注意事项
String的.len()返回字节数不是字符数- 不能用
s[n]索引访问字符,用.chars().nth(n)或先转成Vec<char> +运算符会消耗左边 String 的所有权,优先用format!宏拼接- 预知字符串大致长度时用
String::with_capacity()预分配,减少扩容开销 String不实现Copy(因为涉及堆内存),赋值是移动而不是复制- 频繁拼接大量小字符串时,先
push_str到一个String比反复用+或format!性能更好
总结
String 是 Rust 中拥有所有权的、可修改的字符串类型,数据存储在堆上,支持追加、插入、删除、替换等操作。创建 String 最常用的方式是 String::from("...") 和 "...".to_string()。拼接字符串推荐用 format! 宏(不消耗所有权)或 push_str(性能好)。String 和 &str 可以方便地互相转换。函数参数优先用 &str,需要拥有数据时用 String。和所有 Rust 的堆类型一样,String 在离开作用域时自动释放内存,不需要手动管理。