blocks|key|5120439|text|TraversableLike上定义的groupBy会生成一个immutable.Map，所以您不能让此方法生成其他内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5120440|已经保留了每个条目中元素的顺序，但没有保留键的顺序。键是所提供函数的结果，因此它们实际上没有顺序。|5120441|如果你想根据一个特定的键第一次出现的情况下订单，这里有一个你可以做的草图。假设我们想按整数的值/2对它们进行分组：|5120442|val+m+=+List(4,+0,+5,+1,+2,+6,+3).zipWithIndex+groupBy+(_._1+/+2)
val+lhm+=+LinkedHashMap(m.toSeq+sortBy+(_._2.head._2):+_*)
lhm+mapValues+(_+map+(_._1))
//+Map(2+->+List(4,+5),+0+->+List(0,+1),+1+->+List(2,+3),+3+->+List(6))
//+Note+order+of+keys+is+same+as+first+occurrence+in+original+list|code-block|syntax|javascript|5120443|entityMap^0|0|F|J|7|V|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

<code>groupBy</code> as defined on <code>TraversableLike</code> produces an <code>immutable.Map</code>, so you can't make this method produce something else.

The order of the elements in each entry is already preserved, but not the order of the keys. The keys are the result of the function supplied, so they don't really have an order.

If you wanted to make an order based on the first occurrence of a particular key, here's a sketch of how you might do it. Say we want to group integers by their value / 2:

<pre><code>val m = List(4, 0, 5, 1, 2, 6, 3).zipWithIndex groupBy (_._1 / 2)
val lhm = LinkedHashMap(m.toSeq sortBy (_._2.head._2): _*)
lhm mapValues (_ map (_._1))
// Map(2 -&gt; List(4, 5), 0 -&gt; List(0, 1), 1 -&gt; List(2, 3), 3 -&gt; List(6))
// Note order of keys is same as first occurrence in original list
</code></pre>

blocks|key|772588|text|下面的代码将为您提供一个groupByOrderedUnique方法，该方法的行为符合您的要求。它还添加了一个groupByOrdered，可以像其他人在评论中所要求的那样保留副本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|772589|import+collection.immutable.ListSet
import+collection.mutable.{LinkedHashMap+=>+MMap,+Builder}

implicit+class+GroupByOrderedImplicitImpl[A](val+t:+Traversable[A])+extends+AnyVal+{
++def+groupByOrderedUnique[K](f:+A+=>+K):+Map[K,+ListSet[A]]+=
++++groupByGen(ListSet.newBuilder[A])(f)

++def+groupByOrdered[K](f:+A+=>+K):+Map[K,+List[A]]+=
++++groupByGen(List.newBuilder[A])(f)

++def+groupByGen[K,+C[_]](makeBuilder:+=>+Builder[A,+C[A]])(f:+A+=>+K):+Map[K,+C[A]]+=+{
++++val+map+=+MMap[K,+Builder[A,+C[A]]]()
++++for+(i+<-+t)+{
++++++val+key+=+f(i)
++++++val+builder+=+map.get(key)+match+{
++++++++case+Some(existing)+=>+existing
++++++++case+None+=>
++++++++++val+newBuilder+=+makeBuilder
++++++++++map(key)+=+newBuilder
++++++++++newBuilder
++++++}
++++++builder+%2B=+i
++++}
++++map.mapValues(_.result).toMap
++}
}|code-block|syntax|javascript|772590|当我使用如下代码时：|772591|import+GroupByOrderedImplicit._
++
val+range+=+0.until(40)
val+in+=+range+%2B%2B+range.reverse
++
println("With+dupes:")
in.groupByOrdered(_+%25+10).toList.sortBy(_._1).foreach(println)
++
println("\nUnique:")
in.groupByOrderedUnique(_+%25+10).toList.sortBy(_._1).foreach(println)|772592|我得到以下输出：|772593|With+dupes:
(0,List(0,+10,+20,+30,+30,+20,+10,+0))
(1,List(1,+11,+21,+31,+31,+21,+11,+1))
(2,List(2,+12,+22,+32,+32,+22,+12,+2))
(3,List(3,+13,+23,+33,+33,+23,+13,+3))
(4,List(4,+14,+24,+34,+34,+24,+14,+4))
(5,List(5,+15,+25,+35,+35,+25,+15,+5))
(6,List(6,+16,+26,+36,+36,+26,+16,+6))
(7,List(7,+17,+27,+37,+37,+27,+17,+7))
(8,List(8,+18,+28,+38,+38,+28,+18,+8))
(9,List(9,+19,+29,+39,+39,+29,+19,+9))

Unique:
(0,ListSet(0,+10,+20,+30))
(1,ListSet(1,+11,+21,+31))
(2,ListSet(2,+12,+22,+32))
(3,ListSet(3,+13,+23,+33))
(4,ListSet(4,+14,+24,+34))
(5,ListSet(5,+15,+25,+35))
(6,ListSet(6,+16,+26,+36))
(7,ListSet(7,+17,+27,+37))
(8,ListSet(8,+18,+28,+38))
(9,ListSet(9,+19,+29,+39))|772594|entityMap^0|C|K|1J|E|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

The following would give you a <code>groupByOrderedUnique</code> method that behaves as you sought. It also adds a <code>groupByOrdered</code> that preserves duplicates as others have asked for in the comments.
<pre><code>import collection.immutable.ListSet
import collection.mutable.{LinkedHashMap =&gt; MMap, Builder}

implicit class GroupByOrderedImplicitImpl[A](val t: Traversable[A]) extends AnyVal {
 def groupByOrderedUnique[K](f: A =&gt; K): Map[K, ListSet[A]] =
 groupByGen(ListSet.newBuilder[A])(f)

 def groupByOrdered[K](f: A =&gt; K): Map[K, List[A]] =
 groupByGen(List.newBuilder[A])(f)

 def groupByGen[K, C[_]](makeBuilder: =&gt; Builder[A, C[A]])(f: A =&gt; K): Map[K, C[A]] = {
 val map = MMap[K, Builder[A, C[A]]]()
 for (i &lt;- t) {
 val key = f(i)
 val builder = map.get(key) match {
 case Some(existing) =&gt; existing
 case None =&gt;
 val newBuilder = makeBuilder
 map(key) = newBuilder
 newBuilder
 }
 builder += i
 }
 map.mapValues(_.result).toMap
 }
}
</code></pre>
When I use that code like:
<pre><code>import GroupByOrderedImplicit._
 
val range = 0.until(40)
val in = range ++ range.reverse
 
println(&quot;With dupes:&quot;)
in.groupByOrdered(_ % 10).toList.sortBy(_._1).foreach(println)
 
println(&quot;\nUnique:&quot;)
in.groupByOrderedUnique(_ % 10).toList.sortBy(_._1).foreach(println)
</code></pre>
I get the following output:
<pre><code>With dupes:
(0,List(0, 10, 20, 30, 30, 20, 10, 0))
(1,List(1, 11, 21, 31, 31, 21, 11, 1))
(2,List(2, 12, 22, 32, 32, 22, 12, 2))
(3,List(3, 13, 23, 33, 33, 23, 13, 3))
(4,List(4, 14, 24, 34, 34, 24, 14, 4))
(5,List(5, 15, 25, 35, 35, 25, 15, 5))
(6,List(6, 16, 26, 36, 36, 26, 16, 6))
(7,List(7, 17, 27, 37, 37, 27, 17, 7))
(8,List(8, 18, 28, 38, 38, 28, 18, 8))
(9,List(9, 19, 29, 39, 39, 29, 19, 9))

Unique:
(0,ListSet(0, 10, 20, 30))
(1,ListSet(1, 11, 21, 31))
(2,ListSet(2, 12, 22, 32))
(3,ListSet(3, 13, 23, 33))
(4,ListSet(4, 14, 24, 34))
(5,ListSet(5, 15, 25, 35))
(6,ListSet(6, 16, 26, 36))
(7,ListSet(7, 17, 27, 37))
(8,ListSet(8, 18, 28, 38))
(9,ListSet(9, 19, 29, 39))
</code></pre>

blocks|key|1793787|text|这里有一个没有地图的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1793788|def+orderedGroupBy[T,+P](seq:+Traversable[T])(f:+T+=>+P):+Seq[(P,+Traversable[T])]+=+{
+++@tailrec
+++def+accumulator(seq:+Traversable[T],+f:+T+=>+P,+res:+List[(P,+Traversable[T])]):+Seq[(P,+Traversable[T])]+=+seq.headOption+match+{
+++++case+None+=>+res.reverse
+++++case+Some(h)+=>+{
+++++++val+key+=+f(h)
+++++++val+subseq+=+seq.takeWhile(f(_)+==+key)
+++++++accumulator(seq.drop(subseq.size),+f,+(key+->+subseq)+::+res)
+++++}
+++}
+++accumulator(seq,+f,+Nil)
+}|code-block|syntax|javascript|1793789|如果您只需要按顺序访问结果(不需要随机访问)，并且希望避免创建和使用Map对象的开销，那么它可能很有用。注意:我没有将性能与其他选项进行比较，它实际上可能更差。|1793790|EDIT:为了清楚起见，这里假设您的输入已经按组键排序。我的用例是SELECT+...+ORDER+BY。|offset|length|style|CODE|1793791|entityMap^0|0|0|0|X|J|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]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's one without maps:

<pre class="lang-scala prettyprint-override"><code>def orderedGroupBy[T, P](seq: Traversable[T])(f: T =&gt; P): Seq[(P, Traversable[T])] = {
 @tailrec
 def accumulator(seq: Traversable[T], f: T =&gt; P, res: List[(P, Traversable[T])]): Seq[(P, Traversable[T])] = seq.headOption match {
 case None =&gt; res.reverse
 case Some(h) =&gt; {
 val key = f(h)
 val subseq = seq.takeWhile(f(_) == key)
 accumulator(seq.drop(subseq.size), f, (key -&gt; subseq) :: res)
 }
 }
 accumulator(seq, f, Nil)
 }
</code></pre>

It could be useful if you only need to access the results sequentially (no random access) and you want to avoid the overhead of creating and using Map objects. Note: I didn't compare the performance against the other options, it could actually be worse.

EDIT: Just to be clear; this assumes your input is already ordered by the group key. My use case is a <code>SELECT ... ORDER BY</code>.

blocks|key|1082388|text|尽管该解决方案与实际的ScalaMeter+groupBy非常相似，但这在scala上产生了更好的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082389|++++::Benchmark+Range.GroupBy::
++++cores:+8
++++hostname:+xxxxx-MacBook-Pro.local
++++name:+Java+HotSpot(TM)+64-Bit+Server+VM
++++osArch:+x86_64
++++osName:+Mac+OS+X
++++vendor:+Oracle+Corporation
++++version:+25.131-b11
++++Parameters(size+->+300000):+6.500884
++++Parameters(size+->+600000):+13.019679
++++Parameters(size+->+900000):+22.756615
++++Parameters(size+->+1200000):+25.481007
++++Parameters(size+->+1500000):+33.129888|code-block|syntax|javascript|1082390|与zipWithIndex方法相比，它产生了|1082391|++++:Benchmark+Range.GroupBy::
++++cores:+8
++++hostname:+xxxxx-MacBook-Pro.local
++++name:+Java+HotSpot(TM)+64-Bit+Server+VM
++++osArch:+x86_64
++++osName:+Mac+OS+X
++++vendor:+Oracle+Corporation
++++version:+25.131-b11
++++Parameters(size+->+300000):+9.57414
++++Parameters(size+->+600000):+18.569085
++++Parameters(size+->+900000):+28.233822
++++Parameters(size+->+1200000):+36.975254
++++Parameters(size+->+1500000):+47.447057|1082392|代码：|1082393|implicit+class+GroupBy[A](val+t:+TraversableOnce[A])+{
++def+sortedGroupBy[K](f:+A+=>+K)(implicit+ordering:+Ordering[K]):+immutable.SortedMap[K,+ArrayBuffer[A]]+=+{
++++val+m+=+mutable.SortedMap.empty[K,+ArrayBuffer[A]]
++++for+(elem+<-+t)+{
++++++val+key+=+f(elem)
++++++val+bldr+=+m.getOrElseUpdate(key,+mutable.ArrayBuffer[A]())
++++++bldr+%2B=+elem
++++}
++++val+b+=+immutable.SortedMap.newBuilder[K,+ArrayBuffer[A]]
++++for+((k,+v)+<-+m)+{
++++++b+%2B=+((k,+v.result))
++++}
++++b.result
++}
}|1082394|示例：val+sizes+=+Gen.range("size")(300000,+1500000,+300000)和groupByOrdered(_+%25+10)|offset|length|style|CODE|1082395|entityMap^0|0|0|0|0|0|0|3|1I|1M|M|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]|$Q|15|R|16|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

This yields better results on ScalaMeter though the solution is very similar to the actual scala groupBy

<pre><code> ::Benchmark Range.GroupBy::
 cores: 8
 hostname: xxxxx-MacBook-Pro.local
 name: Java HotSpot(TM) 64-Bit Server VM
 osArch: x86_64
 osName: Mac OS X
 vendor: Oracle Corporation
 version: 25.131-b11
 Parameters(size -&gt; 300000): 6.500884
 Parameters(size -&gt; 600000): 13.019679
 Parameters(size -&gt; 900000): 22.756615
 Parameters(size -&gt; 1200000): 25.481007
 Parameters(size -&gt; 1500000): 33.129888
</code></pre>

compared to the one that zipWithIndex approach which yields

<pre><code> :Benchmark Range.GroupBy::
 cores: 8
 hostname: xxxxx-MacBook-Pro.local
 name: Java HotSpot(TM) 64-Bit Server VM
 osArch: x86_64
 osName: Mac OS X
 vendor: Oracle Corporation
 version: 25.131-b11
 Parameters(size -&gt; 300000): 9.57414
 Parameters(size -&gt; 600000): 18.569085
 Parameters(size -&gt; 900000): 28.233822
 Parameters(size -&gt; 1200000): 36.975254
 Parameters(size -&gt; 1500000): 47.447057
</code></pre>

Code:

<pre><code>implicit class GroupBy[A](val t: TraversableOnce[A]) {
 def sortedGroupBy[K](f: A =&gt; K)(implicit ordering: Ordering[K]): immutable.SortedMap[K, ArrayBuffer[A]] = {
 val m = mutable.SortedMap.empty[K, ArrayBuffer[A]]
 for (elem &lt;- t) {
 val key = f(elem)
 val bldr = m.getOrElseUpdate(key, mutable.ArrayBuffer[A]())
 bldr += elem
 }
 val b = immutable.SortedMap.newBuilder[K, ArrayBuffer[A]]
 for ((k, v) &lt;- m) {
 b += ((k, v.result))
 }
 b.result
 }
}
</code></pre>

example: <code>val sizes = Gen.range("size")(300000, 1500000, 300000)</code> and 
 <code>groupByOrdered(_ % 10)</code>

The groupBy method in Lists, Maps, etc., generate a Map after the function. 

Is there a way to use the groupBy to generate a Map that preserves insertion order (LinkedHashMap, for instance)?

I'm using for loops to insert manually, but I wanted to know if one of the useful already-defined functions could help me.

Thanks in advance.

Scala GroupBy preserving insertion order?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

列表、地图等中的groupBy方法在函数之后生成一个地图。有没有一种方法可以使用groupBy生成保持插入顺序的映射(例如LinkedHashMap)？我使用for循环来手动插入，但我想知道是否有一个有用的已定义函数可以帮助我。提前谢谢。

问Scala GroupBy保持插入顺序？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala GroupBy保持插入顺序？EN