Rust語(yǔ)言從入門(mén)到精通系列之Iterator迭代器深入詳解

更新時(shí)間：2023年04月20日 16:42:27 作者：TinyZzh

這篇文章主要為大家介紹了Rust語(yǔ)言從入門(mén)到精通系列之Iterator迭代器深入詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

在Rust語(yǔ)言中，迭代器（Iterator）是一種極為重要的數(shù)據(jù)類(lèi)型，它們用于遍歷集合中的元素。Rust中的大多數(shù)集合類(lèi)型都可轉(zhuǎn)換為一個(gè)迭代器，使它們可以進(jìn)行遍歷，這包括數(shù)組、向量、哈希表等。

使用迭代器可以讓代碼更加簡(jiǎn)潔優(yōu)雅，并且可以支持一些強(qiáng)大的操作，例如過(guò)濾、映射和折疊等。

在本文中，我們將探討Rust語(yǔ)言中的迭代器的相關(guān)知識(shí)，并且以我們的老朋友Animal為例，提供相關(guān)的示例代碼。

熟悉Java的Stream和Lambda的同學(xué)，學(xué)習(xí)本章節(jié)時(shí)，會(huì)格外的感覺(jué)“親切”。

迭代器的基本概念

迭代器是什么？

在Rust中，迭代器是一個(gè)實(shí)現(xiàn)了Iterator trait的類(lèi)型。該trait定義了一組行為，用于支持遍歷集合中的元素。通過(guò)實(shí)現(xiàn)Iterator trait，類(lèi)型可以被轉(zhuǎn)換為一個(gè)迭代器，從而支持Iterate的操作。

Iterator trait

Iterator trait 定義了迭代器的核心行為，它包含了next方法和一些其他方法。next方法返回集合中下一個(gè)元素的Option值，直到集合中所有的元素都被遍歷完畢，返回None。

除了next方法之外，Iterator trait 還定義了其他許多有用的方法，比如map、filter等，這些方法可以對(duì)迭代器中的元素進(jìn)行操作和轉(zhuǎn)換。

pub trait Iterator {
      type Item;
    fn next(&amp;mut self) -&gt; Option&lt;Self::Item&gt;;
    //  多種內(nèi)置實(shí)現(xiàn)方法, skip, map, reduce, collect
    //  和Java中的Stream內(nèi)置方法非常類(lèi)似.
}

Animal示例

接下來(lái)我們探討實(shí)現(xiàn)一個(gè)Animal迭代器，Animal實(shí)現(xiàn)Iterator trait，使其可以通過(guò)迭代器遍歷Animal的各個(gè)屬性。以下是Animal類(lèi)型的定義：

#[derive(Debug)]
struct Animal {
    name: String,
    age: u32,
    kind: String,
    i:i32,
}

我們可以在Animal上實(shí)現(xiàn)Iterator trait，使其可以通過(guò)for循環(huán)進(jìn)行迭代。

impl Iterator for Animal {
      type Item = String;
    fn next(&amp;mut self) -&gt; Option&lt;Self::Item&gt; {
          let next_attribute = match self.i {
            0 =&gt; Some(self.name.clone()),
            1 =&gt; Some(self.age.to_string()),
            2 =&gt; Some(self.kind.clone()),
            _ =&gt; None,
        };
        self.i += 1;
        next_attribute
    }
}

此時(shí)，我們已經(jīng)將我們的類(lèi)型轉(zhuǎn)換為迭代器，我們就可以在它上面調(diào)用各種Iterator trait 的方法。例如，我們可以使用for循環(huán)遍歷Animal對(duì)象的每一個(gè)屬性：

#[derive(Debug)]
struct Animal {
    name: String,
    age: u32,
    kind: String,
    i:i32,
}
impl Iterator for Animal {
      type Item = String;
    fn next(&amp;mut self) -&gt; Option&lt;Self::Item&gt; {
          let next_attribute = match self.i {
            0 =&gt; Some(self.name.clone()),
            1 =&gt; Some(self.age.to_string()),
            2 =&gt; Some(self.kind.clone()),
            _ =&gt; None,
        };
        self.i += 1;
        next_attribute
    }
}
fn main() {
    let mut animal = Animal {
        name: "Tom".to_string(),
        age : 15,
        kind: "cat".to_string(),
        i : 0
    };
    println!("Name: {}", animal.next().unwrap());
    println!("Age: {}", animal.next().unwrap());
    println!("Kind: {}", animal.next().unwrap());
}
//  輸出結(jié)果：
// Name: Tom
// Age: 15
// Kind: cat

在上述代碼中，我們定義了一個(gè)Animal類(lèi)型的Iterator，并定義了一個(gè)名為i的內(nèi)部狀態(tài)變量。該變量用于追蹤遍歷的進(jìn)度，并決定下一個(gè)迭代器值的內(nèi)容。最終成功打印了animal的全部信息。

下面繼續(xù)我們的學(xué)習(xí)，定一個(gè)Animal向量并遍歷打印每一個(gè)Animal的所有屬性：

fn print_all_attributes(animals: Vec&lt;Animal&gt;) {
    for mut animal in animals {
        println!("Name: {}", animal.next().unwrap());
        println!("Age: {}", animal.next().unwrap());
        println!("Kind: {}", animal.next().unwrap());
    }
}
fn main() {
    let animals = vec![Animal {
        name: "Tom".to_string(),
        age : 15,
        kind: "cat".to_string(),
        i : 0
    }];
    print_all_attributes(animals);
}
//  輸出結(jié)果：
// Name: Tom
// Age: 15
// Kind: cat

在上述代碼中，我們使用for循環(huán)來(lái)遍歷所有的Animal對(duì)象，并逐一打印它們的屬性。

迭代器的常見(jiàn)用法

map方法

map方法是Iterator trait 中非常重要的一個(gè)方法，它可以讓我們對(duì)迭代器中的每一個(gè)元素進(jìn)行轉(zhuǎn)換操作，并返回新的迭代器。例如：

fn main() {
    let animals = vec![Animal {
        name: "Tom".to_string(),
        age : 15,
        kind: "cat".to_string(),
        i : 0
    }, Animal {
        name: "Jerry".to_string(),
        age : 7,
        kind: "mouse".to_string(),
        i : 0
    }];
    let list: Vec&lt;String&gt; = animals
        .into_iter()
        .map(|ani| ani.name.clone())
        .collect();
    println!("{:?}", list)
}
// 輸出 ["Tom", "Jerry"]

上述代碼中，我們定義了一個(gè)包含2個(gè)的向量animals，并使用iter方法將其轉(zhuǎn)換為一個(gè)迭代器。然后，我們使用map方法對(duì)這個(gè)迭代器中的Animal的name操作，返回一個(gè)新的迭代器，并使用collect方法將其轉(zhuǎn)換為向量list。

filter方法

假設(shè)我們現(xiàn)在想尋找年齡大于等于3歲的動(dòng)物，我們可以使用filter方法來(lái)實(shí)現(xiàn)。

fn main() {
    let animals = vec![Animal {
        name: "Tom".to_string(),
        age : 15,
        kind: "cat".to_string(),
        i : 0
    }];
    let filtered_animals: Vec&lt;Animal&gt; = animals
        .into_iter()
        .filter(|animal| animal.age &gt;= 3)
        .collect();
    println!("{:?}", filtered_animals)
}
//  輸出結(jié)果：
//  [Animal { name: "Tom", age: 15, kind: "cat", i: 0 }]

在上述代碼中，我們使用into_iter方法將Animal向量轉(zhuǎn)換為迭代器，并使用filter方法過(guò)濾其中年齡大于等于3歲的動(dòng)物，最終返回一個(gè)新的Animal向量。

enumerate方法

enumerate方法會(huì)將一個(gè)迭代器中的元素和它們的索引配對(duì)，并返回一個(gè)新的迭代器。例如：

fn main() {
    let animals = vec![Animal {
        name: "Tom".to_string(),
        age : 15,
        kind: "cat".to_string(),
        i : 0
    }, Animal {
        name: "Jerry".to_string(),
        age : 7,
        kind: "mouse".to_string(),
        i : 0
    }];
    for (i, animal) in animals.iter().enumerate() {
        println!("{}: {:?}", i, animal);
    }
}
// 輸出：
// 0: Animal { name: "Tom", age: 15, kind: "cat", i: 0 }
// 1: Animal { name: "Jerry", age: 7, kind: "mouse", i: 0 }

上述代碼中，我們定義了一個(gè)包含2個(gè)Animal的向量animals，并使用iter方法將其轉(zhuǎn)換為一個(gè)迭代器。然后，我們使用enumerate方法將每Animal與其索引配對(duì)，并在for循環(huán)中打印出來(lái)。

flat_map方法

flat_map方法是Iterator trait 中比較少見(jiàn)的方法之一，它可以用于將嵌套的迭代器展開(kāi)為單個(gè)迭代器。例如：

#[derive(Debug, Clone)]
struct Animal {
    name: String,
    age: u32,
    kind: String,
    i: i32,
}
fn main() {
    let cat = Animal {
        name: "Tom".to_string(),
        age: 15,
        kind: "cat".to_string(),
        i: 0,
    };
    let mouse = Animal {
        name: "Jerry".to_string(),
        age: 7,
        kind: "mouse".to_string(),
        i: 0,
    };
    let animals = vec![vec![cat], vec![mouse]];
    let list: Vec&lt;Animal&gt; = animals.iter().flat_map(|x| x.iter().cloned()).collect();
    println!("{:?}", list)
}
// 輸出 [Animal { name: "Tom", age: 15, kind: "cat", i: 0 }, Animal { name: "Jerry", age: 7, kind: "mouse", i: 0 }]

上述代碼中，我們定義了一個(gè)二維向量animals，并使用iter方法將它轉(zhuǎn)換為迭代器。然后，我們使用flat_map方法將它展開(kāi)為一個(gè)一維的迭代器，并使用collect方法將其轉(zhuǎn)換為向量list。

zip方法

如果我們需要同時(shí)遍歷兩個(gè)向量，我們可以使用zip方法進(jìn)行配對(duì)。

fn main() {
    let names = vec!["Tom", "Jerry", "Bob"];
    let ages = vec![3, 4, 5];
    for (name, age) in names.iter().zip(ages.iter()) {
          println!("{} is {} years old.", name, age);
    }
}
//    輸出結(jié)果：
// Tom is 3 years old.
// Jerry is 4 years old.
// Bob is 5 years old.

上述代碼中，我們使用iter方法將names和ages向量轉(zhuǎn)換為迭代器，并使用zip方法對(duì)它們進(jìn)行配對(duì)。對(duì)于每一對(duì)元素，我們調(diào)用println!函數(shù)并打印它們。

fold方法

fold方法在Rust中也十分重要，它可以接受一個(gè)初始值和一個(gè)閉包，遍歷迭代器中的每一個(gè)元素，并將它們合并成單個(gè)值。例如：

fn main() {
    let cat = Animal {
        name: "Tom".to_string(),
        age: 15,
        kind: "cat".to_string(),
        i: 0,
    };
    let mouse = Animal {
        name: "Jerry".to_string(),
        age: 7,
        kind: "mouse".to_string(),
        i: 0,
    };
    let animals = vec![cat, mouse];
    let sum = animals.iter().fold(0, |t, ani| t + ani.age );
    println!("{}", sum)
}
// 輸出 22

上述代碼中，我們定義了一個(gè)包含2個(gè)Animal的向量animals，并使用iter方法將其轉(zhuǎn)換為一個(gè)迭代器。然后，我們使用fold方法對(duì)這個(gè)迭代器中的age進(jìn)行累加，并返回結(jié)果sum。

結(jié)論

迭代器是Rust語(yǔ)言中非常重要的數(shù)據(jù)類(lèi)型，它們用于遍歷集合中的元素，并支持各種操作。在本教程中，我們探討了迭代器的基本概念和常見(jiàn)用法，以Animal為例子，提供了相應(yīng)的演示代碼。希望讀者能夠掌握Rust迭代器的相關(guān)內(nèi)容，并且在實(shí)際編程中得到應(yīng)用。

以上就是Rust語(yǔ)言從入門(mén)到精通系列之Iterator迭代器深入詳解的詳細(xì)內(nèi)容，更多關(guān)于Rust Iterator迭代器的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: