String 堆分配字符串 ​

什么是 String ​

String 是 Rust 中可增长、可修改、拥有所有权的字符串类型。它的数据存储在堆上,由三部分组成:指向堆内存的指针、当前长度(已使用的字节数)和容量(已分配的字节数)。String 内部保证数据始终是合法的 UTF-8 编码。

和 &str 不同,String 拥有自己的数据,可以修改内容、追加文本、插入删除字符。当 String 变量离开作用域时,它持有的堆内存会自动释放。

rust
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 的方式 ​

rust
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 ​

rust
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
}

字符串拼接 ​

rust
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
}

容量管理 ​

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 格式化器:

rust
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 之间怎么转换?

rust
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 在离开作用域时自动释放内存,不需要手动管理。