07-rust基础-String

String 类型的概述

在 Rust 中，String 是一种可变的、堆分配的、动态大小的字符串类型。与 &str（字符串切片）不同，String 允许你对字符串进行修改，并且可以动态地增长或缩小。

String 的特性

1. 堆分配：

   • String 类型将数据存储在堆上，意味着它可以动态地分配和释放内存。相比之下，&str 是一个不可变的、指向静态内存的字符串切片，它不能进行修改。

2. 可变性：

   • String 允许你修改字符串的内容，添加字符、删除字符等，而 &str 是不可变的。

3. 与 &str 互操作：

   • 虽然 String 和 &str 类型不同，但它们之间可以相互转换。例如，你可以使用 .to_string() 方法将 &str 转换为 String，反之，使用 as_str() 将 String 转为 &str。

创建和使用 String

1. 创建一个空的 String

   let mut s = String::new();
   s.push_str("Hello");
   s.push(' '); // 可以将字符添加到字符串
   s.push_str("World");
   println!("{}", s); // 输出 "Hello World"

2. 使用 to_string() 创建 String

   to_string() 方法可以将 &str 转换为 String 类型。

   let s = "hello".to_string();
   println!("{}", s); // 输出 "hello"

3. 从字面量创建 String

   你也可以通过 String::from 来创建一个 String。

   let s = String::from("Rust");
   println!("{}", s); // 输出 "Rust"

String 的常用方法

1. 添加内容

   • push_str：将一个字符串切片追加到 String 末尾。

     let mut s = String::from("Hello");
     s.push_str(" World");
     println!("{}", s); // 输出 "Hello World"

   • push：将一个字符追加到 String 末尾。

     let mut s = String::from("Hello");
     s.push('!');
     println!("{}", s); // 输出 "Hello!"

2. 移除内容

   • pop：从 String 的末尾删除并返回一个字符。

     let mut s = String::from("Hello!");
     let ch = s.pop();
     println!("{:?}, {}", ch, s); // 输出 'Some('!'), "Hello"

   • remove：移除指定位置的字符。

     let mut s = String::from("Hello");
     let removed_char = s.remove(1); // 移除索引位置 1 的字符
     println!("Removed: {}, Remaining: {}", removed_char, s); // 输出 "Removed: e, Remaining: Hllo"

3. 获取字符串长度

   • len：获取字符串的字节数。

     let s = String::from("Hello");
     println!("{}", s.len()); // 输出 5

4. 检查字符串是否为空

   • is_empty：检查字符串是否为空。

     let s = String::new();
     println!("{}", s.is_empty()); // 输出 true

5. 截取子串

   • get：获取字符串的一个子切片（返回 Option<&str>，如果索引越界，则返回 None）。

     let s = String::from("Hello, world!");
     if let Some(sub) = s.get(0..5) {
         println!("{}", sub); // 输出 "Hello"
     }

从 String 到 &str 和反向转换

• 从 String 到 &str：

  使用 .as_str() 可以将 String 转换为 &str：

  let s = String::from("Hello");
  let slice: &str = s.as_str();
  println!("{}", slice); // 输出 "Hello"

• 从 &str 到 String：

  使用 to_string() 或 String::from() 可以将 &str 转换为 String：

  let s = "Hello";
  let string = s.to_string();
  println!("{}", string); // 输出 "Hello"

性能和内存管理

• String 在 Rust 中使用内存池来进行堆分配，当字符串的容量不足时，Rust 会自动为其分配更大的内存。这个过程由 Rust 的内存管理系统进行优化。

• String 使用了引用计数和智能指针等技术来确保内存的安全性和高效性，并且通过 Rust 的所有权系统避免了内存泄漏。

String的方法总结

下面是 String 类型在 Rust 中常用方法的总结，按功能分类的表格：

方法名	说明	示例
new	创建一个空的 String。	let s = String::new();
from	从 &str 创建一个 String。	let s = String::from("hello");
to_string	将 &str 转换为 String。	let s = "hello".to_string();
push_str	向 String 末尾追加一个字符串切片。	let mut s = String::from("hello"); s.push_str(" world");
push	向 String 末尾追加一个字符。	let mut s = String::from("hello"); s.push('!');
pop	从 String 的末尾移除并返回一个字符。返回 Option<char> 类型。	let mut s = String::from("hello"); let c = s.pop();
remove	移除指定位置的字符，并返回该字符。	let mut s = String::from("hello"); let ch = s.remove(1);
len	获取字符串的字节数（而非字符数）。	let s = String::from("hello"); let len = s.len();
is_empty	检查 String 是否为空。	let s = String::new(); println!("{}", s.is_empty());
get	获取指定范围的子字符串（返回 Option<&str>）。	let s = String::from("hello"); let sub = s.get(0..3);
as_str	将 String 转换为 &str。	let s = String::from("hello"); let slice: &str = s.as_str();
contains	判断 String 是否包含某个子字符串。	let s = String::from("hello"); let b = s.contains("ell");
replace	替换子字符串。	let s = String::from("hello"); let new_str = s.replace("e", "a");
trim	去除字符串两端的空白字符。	let s = String::from(" hello "); let trimmed = s.trim();
to_lowercase	将 String 转换为小写。	let s = String::from("HELLO"); let lower = s.to_lowercase();
to_uppercase	将 String 转换为大写。	let s = String::from("hello"); let upper = s.to_uppercase();
starts_with	检查 String 是否以指定的子字符串开始。	let s = String::from("hello"); let b = s.starts_with("he");
ends_with	检查 String 是否以指定的子字符串结束。	let s = String::from("hello"); let b = s.ends_with("lo");
split	根据分隔符将字符串切分为多个子字符串。	let s = String::from("apple,banana,orange"); let parts: Vec<&str> = s.split(',').collect();
replace_range	替换指定范围内的字符。	let mut s = String::from("hello"); s.replace_range(1..3, "a");
reserve	预留一定的空间，以避免多次分配内存。	let mut s = String::from("hello"); s.reserve(10);
truncate	截断 String，保留指定长度的前缀。	let mut s = String::from("hello world"); s.truncate(5);
capacity	获取当前分配的内存容量（字节数）。	let s = String::from("hello"); let cap = s.capacity();
clear	清空 String，但不释放其分配的内存。	let mut s = String::from("hello"); s.clear();

&str字符串切面量方法总结

在 Rust 中，字符串切面量（string literal）是指 &str 类型的值。字符串切面量是对内存中的一段已存在字符串的引用，因此它们并不像 String 那样拥有许多方法，因为它们本身是不可变的引用。

方法	描述
len()	返回字符串的字节长度
is_empty()	检查字符串是否为空
to_string()	将 &str 转换为 String
trim()	去掉字符串两端的空白字符，返回一个新的 &str
contains()	检查 &str 中是否包含指定的子字符串
starts_with()	判断 &str 是否以指定的子字符串开头
ends_with()	判断 &str 是否以指定的子字符串结尾
replace()	替换子字符串并返回新的 String
split()	将 &str 分割成一个迭代器（返回切割后的多个子串）
chars()	返回一个迭代器，允许逐个字符地遍历 &str
find()	查找子字符串的位置（返回一个可选类型）
to_lowercase()	返回一个新的 String，其中的字符转换为小写
to_uppercase()	返回一个新的 String，其中的字符转换为大写
replace()	替换字符串中的子串并返回一个新的 String