blocks|key|1842089|text|您可以构造一个具有可变数量的元组的Map。因此，在集合上使用映射方法将其转换为元组的集合，然后使用：_*技巧将结果转换为变量参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842090|scala>+val+list+=+List("this",+"maps",+"string",+"to",+"length")+map+{s+=>+(s,+s.length)}
list:+List[(java.lang.String,+Int)]+=+List((this,4),+(maps,4),+(string,6),+(to,2),+(length,6))

scala>+val+list+=+List("this",+"is",+"a",+"bunch",+"of",+"strings")
list:+List[java.lang.String]+=+List(this,+is,+a,+bunch,+of,+strings)

scala>+val+string2Length+=+Map(list+map+{s+=>+(s,+s.length)}+:+_*)
string2Length:+scala.collection.immutable.Map[java.lang.String,Int]+=+Map(strings+->+7,+of+->+2,+bunch+->+5,+a+->+1,+is+->+2,+this+->+4)|code-block|syntax|javascript|1842091|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can construct a Map with a variable number of tuples. So use the map method on the collection to convert it into a collection of tuples and then use the : _* trick to convert the result into a variable argument.

<pre><code>scala&gt; val list = List("this", "maps", "string", "to", "length") map {s =&gt; (s, s.length)}
list: List[(java.lang.String, Int)] = List((this,4), (maps,4), (string,6), (to,2), (length,6))

scala&gt; val list = List("this", "is", "a", "bunch", "of", "strings")
list: List[java.lang.String] = List(this, is, a, bunch, of, strings)

scala&gt; val string2Length = Map(list map {s =&gt; (s, s.length)} : _*)
string2Length: scala.collection.immutable.Map[java.lang.String,Int] = Map(strings -&gt; 7, of -&gt; 2, bunch -&gt; 5, a -&gt; 1, is -&gt; 2, this -&gt; 4)
</code></pre>

blocks|key|1842105|text|除了@James+Iry的解决方案之外，还可以使用fold来实现这一点。我怀疑这种解决方案比元组方法稍微快一点(创建的垃圾对象更少)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842106|val+list+=+List("this",+"maps",+"string",+"to",+"length")
val+map+=+list.foldLeft(Map[String,+Int]())+{+(m,+s)+=>+m(s)+=+s.length+}|code-block|syntax|javascript|1842107|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In addition to @James Iry's solution, it is also possible to accomplish this using a fold. I suspect that this solution is slightly faster than the tuple method (fewer garbage objects are created):

<pre><code>val list = List("this", "maps", "string", "to", "length")
val map = list.foldLeft(Map[String, Int]()) { (m, s) =&gt; m(s) = s.length }
</code></pre>

blocks|key|2056312|text|您可以使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2056313|c+map+(t+=>+t.getP+->+t)+toMap|code-block|syntax|javascript|2056314|但请注意，这需要2次遍历。|2056315|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use

<pre><code>c map (t =&gt; t.getP -&gt; t) toMap
</code></pre>

but be aware that this needs 2 traversals.

blocks|key|1842141|text|对于它的价值，这里有两个毫无意义的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842142|scala>+case+class+Foo(bar:+Int)
defined+class+Foo

scala>+import+scalaz._,+Scalaz._
import+scalaz._
import+Scalaz._

scala>+val+c+=+Vector(Foo(9),+Foo(11))
c:+scala.collection.immutable.Vector[Foo]+=+Vector(Foo(9),+Foo(11))

scala>+c.map(((_:+Foo).bar)+&&&+identity).toMap
res30:+scala.collection.immutable.Map[Int,Foo]+=+Map(9+->+Foo(9),+11+->+Foo(11))

scala>+c.map(((_:+Foo).bar)+>>=+(Pair.apply[Int,+Foo]+_).curried).toMap
res31:+scala.collection.immutable.Map[Int,Foo]+=+Map(9+->+Foo(9),+11+->+Foo(11))|code-block|syntax|javascript|1842143|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For what it's worth, here are two pointless ways of doing it:

<pre><code>scala&gt; case class Foo(bar: Int)
defined class Foo

scala&gt; import scalaz._, Scalaz._
import scalaz._
import Scalaz._

scala&gt; val c = Vector(Foo(9), Foo(11))
c: scala.collection.immutable.Vector[Foo] = Vector(Foo(9), Foo(11))

scala&gt; c.map(((_: Foo).bar) &amp;&amp;&amp; identity).toMap
res30: scala.collection.immutable.Map[Int,Foo] = Map(9 -&gt; Foo(9), 11 -&gt; Foo(11))

scala&gt; c.map(((_: Foo).bar) &gt;&gt;= (Pair.apply[Int, Foo] _).curried).toMap
res31: scala.collection.immutable.Map[Int,Foo] = Map(9 -&gt; Foo(9), 11 -&gt; Foo(11))
</code></pre>

blocks|key|1842175|text|另一种解决方案(可能不适用于所有类型)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842176|import+scala.collection.breakOut
val+m:Map[P,+T]+=+c.map(t+=>+(t.getP,+t))(breakOut)|code-block|syntax|javascript|1842177|这避免了创建中介列表，更多信息请单击此处：Scala+2.8+breakOut|offset|length|1842178|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1715681/scala-2-8-breakout^0|0|0|L|I|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Another solution (might not work for all types)

<pre><code>import scala.collection.breakOut
val m:Map[P, T] = c.map(t =&gt; (t.getP, t))(breakOut)
</code></pre>

this avoids the creation of the intermediary list, more info here:
<a href="https://stackoverflow.com/questions/1715681/scala-2-8-breakout">Scala 2.8 breakOut</a>

blocks|key|2056354|text|c+map+(_.getP)+zip+c|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2056355|运行良好，非常直观|unstyled|2056356|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>c map (_.getP) zip c
</code></pre>

Works well and is very intuitiv

blocks|key|1842215|text|这对我来说很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842216|val+personsMap+=+persons.foldLeft(scala.collection.mutable.Map[Int,+PersonDTO]())+{
++++(m,+p)+=>+m(p.id)+=+p;+m
}|code-block|syntax|javascript|1842217|map必须是可变的，并且Map必须返回，因为添加到可变Map不会返回Map。|1842218|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This works for me:

<pre><code>val personsMap = persons.foldLeft(scala.collection.mutable.Map[Int, PersonDTO]()) {
 (m, p) =&gt; m(p.id) = p; m
}
</code></pre>

The Map has to be mutable and the Map has to be return since adding to a mutable Map does not return a map.

blocks|key|1842321|text|你想要实现的目标有点不明确。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842322|如果c中的两个或多个项目共享同一个p，该怎么办？哪个项目将被映射到映射中的那个p？|offset|length|style|CODE|1842323|更准确的方法是在p和所有具有它的c项之间生成一个映射：|1842324|val+m:+Map[P,+Collection[T]]|code-block|syntax|javascript|1842325|这可以通过groupBy很容易地实现|1842326|val+m:+Map[P,+Collection[T]]+=+c.groupBy(t+=>+t.p)|1842327|如果您仍然需要原始地图，例如，可以将p映射到具有它的第一个t：|1842328|val+m:+Map[P,+T]+=+c.groupBy(t+=>+t.p)+map+{+case+(p,+ts)+=>++p+->+ts.head+}|1842329|entityMap|0|LINK|mutability|MUTABLE|url|http://www.scala-lang.org/api/current/index.html#scala.collection.GenTraversableLike@groupBy[K](f:A=%253EK):scala.collection.GenMap[K,Repr])^0|0|2|1|H|1|13|1|0|8|1|G|1|0|0|5|7|0|0|0|I|1|T|1|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1C|8|@$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1I|8|@]|9|@$D|1J|E|1K|1|1L]]|A|$]]|$1|Q|3|R|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1N|8|@$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1S|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

What you're trying to achieve is a bit undefined. 
What if two or more items in <code>c</code> share the same <code>p</code>? Which item will be mapped to that <code>p</code> in the map?

The more accurate way of looking at this is yielding a map between <code>p</code> and all <code>c</code> items that have it:

<pre><code>val m: Map[P, Collection[T]]
</code></pre>

This could be easily achieved with <a href="http://www.scala-lang.org/api/current/index.html#scala.collection.GenTraversableLike@groupBy[K](f:A=%3EK):scala.collection.GenMap[K,Repr]" rel="noreferrer">groupBy</a>:

<pre><code>val m: Map[P, Collection[T]] = c.groupBy(t =&gt; t.p)
</code></pre>

If you still want the original map, you can, for instance, map <code>p</code> to the first <code>t</code> that has it:

<pre><code>val m: Map[P, T] = c.groupBy(t =&gt; t.p) map { case (p, ts) =&gt; p -&gt; ts.head }
</code></pre>

blocks|key|2056535|text|这可以不变地实现，并且可以通过折叠集合进行一次遍历，如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2056536|val+map+=+c.foldLeft(Map[P,+T]())+{+(m,+t)+=>+m+%2B+(t.getP+->+t)+}|code-block|syntax|javascript|2056537|这个解决方案之所以有效，是因为添加到不可变Map会返回一个新的不可变Map，其中包含额外的条目，并且这个值在折叠操作中充当累加器。|2056538|这里的折衷是代码的简单性和效率。因此，对于大型集合，这种方法可能比使用2个遍历实现(如应用map和toMap+)更合适。|offset|length|style|CODE|2056539|entityMap^0|0|0|0|19|3|1D|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

This can be implemented immutably and with a single traversal by folding through the collection as follows.

<pre><code>val map = c.foldLeft(Map[P, T]()) { (m, t) =&gt; m + (t.getP -&gt; t) }
</code></pre>

The solution works because adding to an immutable Map returns a new immutable Map with the additional entry and this value serves as the accumulator through the fold operation.

The tradeoff here is the simplicity of the code versus its efficiency. So, for large collections, this approach may be more suitable than using 2 traversal implementations such as applying <code>map</code> and <code>toMap</code>.

blocks|key|1842521|text|在集合上使用map()，后跟toMap|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842522|val+map+=+list.map(e+=>+(e,+e.length)).toMap|code-block|syntax|javascript|1842523|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

use map() on collection followed with toMap

<pre><code>val map = list.map(e =&gt; (e, e.length)).toMap
</code></pre>

blocks|key|1842554|text|使用zip和toMap怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842555|myList.zip(myList.map(_.length)).toMap|code-block|syntax|javascript|1842556|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about using zip and toMap?

<pre><code>myList.zip(myList.map(_.length)).toMap
</code></pre>

blocks|key|2056688|text|Scala+2.13%2B|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2056689|代替"breakOut“，你可以使用|2056690|c.map(t+=>+(t.getP,+t)).to(Map)|offset|length|style|CODE|2056691|滚动到“视图”：https://www.scala-lang.org/blog/2017/02/28/collections-rework.html|2056692|entityMap|0|LINK|mutability|MUTABLE|url|https://www.scala-lang.org/blog/2017/02/28/collections-rework.html^0|0|0|0|V|0|8|1U|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@$F|W|G|X|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

Scala 2.13+
instead of &quot;breakOut&quot; you could use
<code>c.map(t =&gt; (t.getP, t)).to(Map)</code>
Scroll to &quot;View&quot;: <a href="https://www.scala-lang.org/blog/2017/02/28/collections-rework.html" rel="nofollow noreferrer">https://www.scala-lang.org/blog/2017/02/28/collections-rework.html</a>

If I have a collection <code>c</code> of type <code>T</code> and there is a property <code>p</code> on <code>T</code> (of type <code>P</code>, say), what is the best way to do a map-by-extracting-key?

<pre><code>val c: Collection[T]
val m: Map[P, T]
</code></pre>

One way is the following:

<pre><code>m = new HashMap[P, T]
c foreach { t =&gt; m add (t.getP, t) }
</code></pre>

But now I need a mutable map. Is there a better way of doing this so that it's in 1 line and I end up with an immutable Map? (Obviously I could turn the above into a simple library utility, as I would in Java, but I suspect that in Scala there is no need)

Scala best way of turning a Collection into a Map-by-key?

Java

如果我有一个类型为T的集合c，并且在T上有一个属性p (比如类型为P )，那么通过提取键来实现映射的最佳方法是什么val c: Collection[T]val m: Map[P, T]一种方法是：m = new HashMap[P, T]c foreach { t => m add (t.getP, t) }但是现在...

问Scala是将集合转换为Map-by-key的最佳方式吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala是将集合转换为Map-by-key的最佳方式吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala是将集合转换为Map-by-key的最佳方式吗？
EN