Rust 如何以功能性方式从列表创建映射？

在Scala中，有一个名为

toMap

的方法，可以处理任何元组列表，并将其转换为映射，其中键是元组上的第一项，值是第二项：

val listOfTuples=列表（（“一”，1），（“两”，2））
val map=listOfTuples.toMap

在锈蚀方面，最接近toMap的是什么？

使用：

换句话说，元组的任何迭代器，其中第一个值可以并且可以转换为

HashMap

。

S

参数不值得讨论，它只是定义了散列方法

另见：

---

我应该做什么更改，以便使用存储在

Vec

中的相同键获取所有值

标准库中没有用于此的单行/函数方法。相反，请使用API：

如果您发现自己经常这样做，您可以创建自己的类型，并为其实现

FromIterator

：

use std::{cmp::Eq, collections::HashMap, hash::Hash, iter::FromIterator};

struct MyCoolType<K: Eq + Hash, V>(HashMap<K, Vec<V>>);

impl<K: Eq + Hash, V> FromIterator<(K, V)> for MyCoolType<K, V> {
    fn from_iter<I>(tuples: I) -> Self
    where
        I: IntoIterator<Item = (K, V)>,
    {
        let mut m = HashMap::new();
        for (k, v) in tuples {
            m.entry(k).or_insert_with(Vec::new).push(v)
        }
        Self(m)
    }
}

fn main() {
    let tuples = vec![("one", 1), ("two", 2), ("one", 3)];
    let MyCoolType(m) = tuples.into_iter().collect();
    println!("{:?}", m);
}

使用std:{cmp:：Eq，collections:：HashMap，hash:：hash，iter:：fromtiterator}；
结构mycoltype（HashMap）；
MyColType的impl FromIterator{
fn来自_iter（元组：I）->Self
哪里
I:迭代器，
{
让mut m=HashMap:：new（）；
对于元组中的（k，v）{
m、 输入（k）.或插入（Vec:：new）.推送（v）
}
自我（m）
}
}
fn main（）{
让元组=vec！[（“一”，1），（“二”，2），（“一”，3）]；
让mycoltype（m）=tuples.into_iter（）.collect（）；
println！（“{：？}”，m）；
}

另见：

---

由于没有提到，这里有一个单行（尽管很长）方法：

使用std:：collections:：HashMap；
fn main（）{
设m:HashMap=[（“年”，2019），（“月”，12）].iter（）.cloned（）.collect（）；
println！（“{：？}”，m）；
}

或者你可以做一件事：

use std::collections::HashMap;

trait Hash {
   fn to_map(&self) -> HashMap<&str, u16>;
}

impl Hash for [(&str, u16)] {
   fn to_map(&self) -> HashMap<&str, u16> {
      self.iter().cloned().collect()
   }
}

fn main() {
   let m = [("year", 2019), ("month", 12)].to_map();
   println!("{:?}", m)
}

使用std:：collections:：HashMap；
特征散列{
fn to_map（&self）->HashMap；
}
[（&str，u16）]{
fn到_映射（&self）->HashMap{
self.iter（）.cloned（）.collect（）
}
}
fn main（）{
设m=[（“年”，2019年），（“月”，12）]to_map（）；
println！（“{：？}”，m）
}

---

很好，因此来自迭代器的

是Rust的
可以从
构建的：）（我知道不是，但肯定更容易理解…）我们有重复的键：
让tuples=vec！[（“一”，1），（“两”，2），（“一”，11）]。当前解决方案的行为如何？我应该做什么样的更改，以获得存储在
Vec
中的具有相同键的所有值？@Nawaz当前解决方案的行为如何？是否有什么东西阻止您自己尝试？“这是回答这类问题的绝佳资源”。@Shepmaster:是的，我应该在操场上试一下。谢谢。：-。。同时感谢您更新解决方案。我想到了：
use std::collections::HashMap;

fn main() {
    let tuples = vec![("one", 1), ("two", 2), ("one", 3)];
    let mut m = HashMap::new();
    for (k, v) in tuples {
        m.entry(k).or_insert_with(Vec::new).push(v)
    }
    println!("{:?}", m);
}

use std::{cmp::Eq, collections::HashMap, hash::Hash, iter::FromIterator};

struct MyCoolType<K: Eq + Hash, V>(HashMap<K, Vec<V>>);

impl<K: Eq + Hash, V> FromIterator<(K, V)> for MyCoolType<K, V> {
    fn from_iter<I>(tuples: I) -> Self
    where
        I: IntoIterator<Item = (K, V)>,
    {
        let mut m = HashMap::new();
        for (k, v) in tuples {
            m.entry(k).or_insert_with(Vec::new).push(v)
        }
        Self(m)
    }
}

fn main() {
    let tuples = vec![("one", 1), ("two", 2), ("one", 3)];
    let MyCoolType(m) = tuples.into_iter().collect();
    println!("{:?}", m);
}

use std::collections::HashMap;

fn main() {
   let m: HashMap<&str, u16> = [("year", 2019), ("month", 12)].iter().cloned().collect();
   println!("{:?}", m);
}

use std::collections::HashMap;

trait Hash {
   fn to_map(&self) -> HashMap<&str, u16>;
}

impl Hash for [(&str, u16)] {
   fn to_map(&self) -> HashMap<&str, u16> {
      self.iter().cloned().collect()
   }
}

fn main() {
   let m = [("year", 2019), ("month", 12)].to_map();
   println!("{:?}", m)
}