Rust 集合与字符串

Eine Sammlung (Collection) ist die häufigste Form der Datenstruktur zur Aufbewahrung von Daten, die Rust-Bibliothek bietet eine Vielzahl von Sammlungstypen, um Entwicklern zu helfen, Operationen mit Datenstrukturen zu behandeln.

Ein Vektor

Ein Vektor (Vector) ist eine Einzelform zur Aufbewahrung mehrerer Werte, diese Struktur speichert gleiche Typen linear im Speicher.

Ein Vektor ist eine lineare Liste, die in Rust durch Vec<T> dargestellt wird.

Die Verwendung des Vektors ähnelt der einer Liste (List), wir können auf diese Weise Vektoren der spezifischen Typen erstellen:

let vector: Vec<i32>= Vec::new();　//　Ein Vektor wird erstellt, der Typ i32　eine leere Vektor
let vector = vec![10,　20,　40,　8];　　　　　//　Durch Erstellen eines Arrays wird ein Vektor erstellt

Wir verwenden oft die Operationen zur Anhängung von Linearlisten, aber die Anhängung und der Push-Operation des Stacks sind im Wesentlichen gleich, daher hat der Vektor nur die Methode push, um einen einzelnen Element hinzuzufügen:

fn main() {
　　　　let mut vector = vec![10,　20,　40,　8];
　　　　vector.push(16);
　　　　vector.push(32);
　　　　vector.push(64);
　　　　println!("{:?}", vector);
}

运行结果：

[10,　20,　40,　80,　160,　320,　64]

Die Methode append wird verwendet, um einen Vektor an den Ende eines anderen Vektors anzuhängen:

fn main() {
　　　　let mut v1: Vec<i32>= vec![10,　20,　40,　8];
　　　　let mut v2: Vec<i32>= vec![160,　320,　64];
　　　　v1.append(&mut v2);
　　　　println!("{:?}", v1);
}

运行结果：

[10,　20,　40,　80,　160,　320,　64]

Die Methode get wird verwendet, um Werte aus dem Vektor abzurufen:

fn main() {
　　　　Wenn während des Durchlaufs der Variable der Wert geändert werden muss:10,　20,　40,　8];
　　　　println!("{}", match v.get(0) {
　　　　　　　　Some(value) => value.to_string(),
　　　　　　　　None => "None".to_string()
　　　　});
}

运行结果：

1

Da die Länge des Vektors nicht logisch abgeleitet werden kann, kann die Methode get nicht garantieren, dass immer ein Wert abgerufen wird, daher ist der Rückgabewert der Methode Option-Enum, der leer sein kann.

Dies ist eine sichere Methode zum Abrufen von Werten, aber das Schreiben kann etwas umständlich sein. Wenn Sie sicher sein können, dass der Index des abzurufenden Werts nicht über den Bereich der Indizes des Vektors hinausgeht, können Sie auch die Syntax der Array-Wertabfrage verwenden:

fn main() {
　　　　Durchlaufen eines Vektors:10,　20,　40,　8];
　　　　println!("{}", v[1]);
}

运行结果：

2

Wenn wir versuchen, v[4] ，那么向量会返回错误。

]] , dann gibt der Vektor einen Fehler zurück.

fn main() {
　　　　Durchlaufen eines Vektors:10let mut v = vec![　320,　57];
　　　　let v = vec![
　　　　　　　　　　　　for i in &v {
　　　　}
}

运行结果：

100
32
57

println!("{}", i);

fn main() {
　　　　Wenn während des Durchlaufs der Variable der Wert geändert werden muss:10let mut v = vec![　320,　57];
　　　　,
　　　　　　　　*for i in &mut v {　+i　5=
　　　　}
}

0;

String-8 Der String-Klasse (String) wurde bis zu diesem Kapitel bereits häufig verwendet, daher sind viele Methoden den Lesern bekannt. Dieses Kapitel behandelt hauptsächlich die Methoden der Strings und UTF

Eigenschaften.

Neuer String:

let string = String::new();

Grundlegende Typen in Strings umwandeln:　1.　　　　　　　　　//　let one =
Ganzzahlen in einen String umwandeln　1let float =3.　　　　　//　.to_string();
Fließkommazahlen in einen String umwandeln　//　let slice = "slice".to_string();

String-Schnipsel in einen String umwandeln-8 Enthält UTF

Zeichenstrings:
let hello = String::from("السلام عليكم");
let hello = String::from("Dobrý den");
let hello = String::from("Hello");
let hello = String::from("שָׁלוֹם");
let hello = String::from("नमस्ते");
let hello = String::from("こんにちは");
let hello = String::from("안녕하세요");
let hello = String::from("你好");
let hello = String::from("Olá");
let hello = String::from("Здравствуйте");

let hello = String::from("Hola");

Stringanhängen:
let mut s = String::from("run");　//　s.push_str("oob");
Hinzufügen von String-Schnipseln　　　　　　　//　s.push('!');

Hinzufügen von Zeichen + Mit

let s1　Zusammenfügen von Strings:
let s2　String::from("Hello, ");
let s3　String::from("world!");1　+　&s2;

=

let s1　= String::from("tic");
let s2　= String::from("tac");
let s3　= String::from("toe");
Diese Syntax kann auch String-Schnipsel enthalten:1　+　"-"　+　&s2　+　"-"　+　&s3;

Verwenden Sie das Makro format!:

let s1　= String::from("tic");
let s2　= String::from("tac");
let s3　= String::from("toe");
let s = format!("{}-{}-{}", s1, s2, s3);

Länge der Zeichenkette:

let s = "hello";
let len = s.len();

Hier ist der Wert von len 5.

let s = "你好";
let len = s.len();

Hier ist der Wert von len 6. Da chinesische Zeichen UTF-8 kodierte, jeder Zeichen ist lang 3 Bytes, daher die Länge6. Aber Rust unterstützt UTF-8 Zeichenobjekte gibt, daher können Sie die Anzahl der Zeichen zählen, indem Sie zunächst die Zeichenkette in eine Zeichensammlung umwandeln:

let s = "hello你好";
let len = s.chars().count();

Hier ist der Wert von len 7weil es insgesamt 7 Die Geschwindigkeit der Zählung der Zeichen ist viel langsamer als die der Länge.

Durchlauf einer Zeichenkette:

fn main() {
　　　　let s = String::from("hello中文");
　　　　for c in s.chars() {
　　　　　　　　println!("{}", c);
　　　　}
}

运行结果：

h
e
l
l
o
中
文

Ein einzelnes Zeichen aus einer Zeichenkette ziehen:

fn main() {
　　　　let s = String::from("EN中文");
　　　　let a = s.chars().nth(2);
　　　　println!("{:?}", a);
}

运行结果：

Some('中')

注意Die nth-Funktion ist ein Verfahren, um einen bestimmten Wert aus einem Iterator auszulesen, bitte verwenden Sie dies nicht während des Durchlaufens! Da UTF-8 Die Länge jedes Zeichens ist nicht unbedingt gleich!

Wenn Sie einen Teil der Zeichenkette abschneiden möchten:

fn main() {
　　　　let s = String::from("EN中文");
　　　　let sub = &s[0..2];
　　　　println!("{}", sub);
}

运行结果：

EN

Bitte beachten Sie jedoch, dass diese Verwendung möglicherweise einen UTF-8 Das wäre ein Fehler, da das Zeichen!

fn main() {
　　　　let s = String::from("EN中文");
　　　　let sub = &s[0..3];
　　　　println!("{}", sub);
}

运行结果：

Der Thread 'main' panizierte bei 'byte index　3　ist nicht eine Zeichengrenze; es liegt innen im '中' (Bytes　2..5) des `EN中文`, src\libcore\str\mod.rs:2069:5　
Hinweis: Führen Sie mit `RUST_BACKTRACE=` aus.1Um eine Backtrace anzuzeigen, verwenden Sie die Umgebungsvariable.

Mapping-Table

Das Mapping-Table (Map) existiert in anderen Sprachen weit verbreitet. Am häufigsten angewendet wird die Hash Map (Schlüssel-Wert-Mapping).

新建一个散列值映射表：

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert("color", "red");
　　　　map.insert("size", ""10　m^2
　　　　println!("{}", map.get("color").unwrap());
}

注意：这里没有声明散列表的泛型，是因为 Rust 的自动判断类型机制。

运行结果：

red

insert 方法和 get 方法是映射表最常用的两个方法。

映射表支持迭代器：

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert("color", "red");
　　　　map.insert("size", ""10　m^2
　　　　for p in map.iter() {
　　　　　　　　println!("{:?}", p);
　　　　}
}

运行结果：

("color", "red")　
("size", ""10　m^2)

迭代元素是表示键值对的元组。

Rust 的映射表是十分方便的数据结构，当使用 insert 方法添加新的键值对的时候，如果已经存在相同的键，会直接覆盖对应的值。如果你想"安全地插入"，就是在确认当前不存在某个键时才执行的插入动作，可以这样：

map.entry("color").or_insert("red");

这句话的意思是如果没有键为 "color" 的键值对就添加它并设定值为 "red"，否则将跳过。

在已经确定有某个键的情况下如果想直接修改对应的值，有更快的办法：

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert(1, "a");
　　　　
　　　　if let Some(x) = map.get_mut(&1) {
　　　　　　　　*x = "b";
　　　　}
}