blocks|key|523630|text|其他答案中的一个更简洁的版本是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|523631|val+s+=+Seq("apple",+"oranges",+"apple",+"banana",+"apple",+"oranges",+"oranges")

s.groupBy(identity).mapValues(_.size)|code-block|syntax|javascript|523632|为原始序列中的每一项提供一个计数的Map：|offset|length|style|CODE|523633|Map(banana+->+1,+oranges+->+3,+apple+->+3)|523634|这个问题是问如何找到特定项目的计数。使用这种方法，解决方案需要将所需的元素映射到其计数值，如下所示：|523635|s.groupBy(identity).mapValues(_.size)("apple")|523636|entityMap^0|0|0|H|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

A somewhat cleaner version of one of the other answers is:

<pre><code>val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")

s.groupBy(identity).mapValues(_.size)
</code></pre>

giving a <code>Map</code> with a count for each item in the original sequence:

<pre><code>Map(banana -&gt; 1, oranges -&gt; 3, apple -&gt; 3)
</code></pre>

The question asks how to find the count of a specific item. With this approach, the solution would require mapping the desired element to its count value as follows:

<pre><code>s.groupBy(identity).mapValues(_.size)("apple")
</code></pre>

blocks|key|523308|text|scala集合确实有count：list.count(_+==+2)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|523309|entityMap^0|A|5|G|I|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

scala collections do have <code>count</code>: <code>list.count(_ == 2)</code>

blocks|key|523458|text|我遇到了和Sharath+Prabhal相同的问题，我得到了另一个(对我来说更清楚)的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|523459|val+s+=+Seq("apple",+"oranges",+"apple",+"banana",+"apple",+"oranges",+"oranges")
s.groupBy(l+=>+l).map(t+=>+(t._1,+t._2.length))|code-block|syntax|javascript|523460|结果是：|523461|Map(banana+->+1,+oranges+->+3,+apple+->+3)|523462|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I had the same problem as Sharath Prabhal, and I got another (to me clearer) solution :

<pre><code>val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
s.groupBy(l =&gt; l).map(t =&gt; (t._1, t._2.length))
</code></pre>

With as result :

<pre><code>Map(banana -&gt; 1, oranges -&gt; 3, apple -&gt; 3)
</code></pre>

blocks|key|523965|text|list.groupBy(i=>i).mapValues(_.size)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|523966|给出|unstyled|523967|Map[Int,+Int]+=+Map(1+->+1,+2+->+3,+7+->+1,+3+->+1,+4+->+3)|523968|请注意，您可以使用内置的identity函数替换(i=>i)：|offset|length|style|CODE|523969|list.groupBy(identity).mapValues(_.size)|523970|entityMap^0|0|0|0|C|8|O|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|Q|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>list.groupBy(i=&gt;i).mapValues(_.size)
</code></pre>

gives

<pre><code>Map[Int, Int] = Map(1 -&gt; 1, 2 -&gt; 3, 7 -&gt; 1, 3 -&gt; 1, 4 -&gt; 3)
</code></pre>

Note that you can replace <code>(i=&gt;i)</code> with built in <code>identity</code> function:

<pre><code>list.groupBy(identity).mapValues(_.size)
</code></pre>

blocks|key|306588|text|val+list+=+List(1,+2,+4,+2,+4,+7,+3,+2,+4)
//+Using+the+provided+count+method+this+would+yield+the+occurrences+of+each+value+in+the+list:
l+map(x+=>+l.count(_+==+x))

List[Int]+=+List(1,+3,+3,+3,+3,+1,+1,+3,+3)
//+This+will+yield+a+list+of+pairs+where+the+first+number+is+the+number+from+the+original+list+and+the+second+number+represents+how+often+the+first+number+occurs+in+the+list:
l+map(x+=>+(x,+l.count(_+==+x)))
//+outputs+=>+List[(Int,+Int)]+=+List((1,1),+(2,3),+(4,3),+(2,3),+(4,3),+(7,1),+(3,1),+(2,3),+(4,3))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|306589|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>val list = List(1, 2, 4, 2, 4, 7, 3, 2, 4)
// Using the provided count method this would yield the occurrences of each value in the list:
l map(x =&gt; l.count(_ == x))

List[Int] = List(1, 3, 3, 3, 3, 1, 1, 3, 3)
// This will yield a list of pairs where the first number is the number from the original list and the second number represents how often the first number occurs in the list:
l map(x =&gt; (x, l.count(_ == x)))
// outputs =&gt; List[(Int, Int)] = List((1,1), (2,3), (4,3), (2,3), (4,3), (7,1), (3,1), (2,3), (4,3))
</code></pre>

blocks|key|306631|text|我遇到了同样的问题，但我想一次计算多个项目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|306632|val+s+=+Seq("apple",+"oranges",+"apple",+"banana",+"apple",+"oranges",+"oranges")
s.foldLeft(Map.empty[String,+Int])+{+(m,+x)+=>+m+%2B+((x,+m.getOrElse(x,+0)+%2B+1))+}
res1:+scala.collection.immutable.Map[String,Int]+=+Map(apple+->+3,+oranges+->+3,+banana+->+1)|code-block|syntax|javascript|306633|https://gist.github.com/sharathprabhal/6890475|offset|length|306634|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1A|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

I ran into the same problem but wanted to count multiple items in one go..

<pre><code>val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
s.foldLeft(Map.empty[String, Int]) { (m, x) =&gt; m + ((x, m.getOrElse(x, 0) + 1)) }
res1: scala.collection.immutable.Map[String,Int] = Map(apple -&gt; 3, oranges -&gt; 3, banana -&gt; 1)
</code></pre>

<a href="https://gist.github.com/sharathprabhal/6890475" rel="noreferrer">https://gist.github.com/sharathprabhal/6890475</a>

blocks|key|307115|text|如果你想像使用list.count(2)一样使用它，你必须使用一个Implicit+Class来实现它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|307116|implicit+class+Count[T](list:+List[T])+{
++def+count(n:+T):+Int+=+list.count(_+==+n)
}

List(1,2,4,2,4,7,3,2,4).count(2)++//+returns+3
List(1,2,4,2,4,7,3,2,4).count(5)++//+returns+0|code-block|syntax|javascript|307117|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scala-lang.org/overviews/core/implicit-classes.html^0|7|D|X|E|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

If you want to use it like <code>list.count(2)</code> you have to implement it using an <a href="http://docs.scala-lang.org/overviews/core/implicit-classes.html" rel="noreferrer" title="Implicit Class">Implicit Class</a>.

<pre><code>implicit class Count[T](list: List[T]) {
 def count(n: T): Int = list.count(_ == n)
}

List(1,2,4,2,4,7,3,2,4).count(2) // returns 3
List(1,2,4,2,4,7,3,2,4).count(5) // returns 0
</code></pre>

blocks|key|523534|text|值得注意的是，为这种情况特意设计的默认值为0的映射显示了最差的性能(并且不像groupBy那样简洁)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|523535|++++type+Word+=+String
++++type+Sentence+=+Seq[Word]
++++type+Occurrences+=+scala.collection.Map[Char,+Int]

++def+woGrouped(w:+Word):+Occurrences+=+{
++++++++w.groupBy(c+=>+c).map({case+(c,+list)+=>+(c+->+list.length)})
++}+++++++++++++++++++++++++++++++++++++++++++++++//>+woGrouped:+(w:+forcomp.threadBug.Word)forcomp.threadBug.Occurrences

++def+woGetElse0Map(w:+Word):+Occurrences+=+{
++++++++val+map+=+Map[Char,+Int]()
++++++++w.foldLeft(map)((m,+c)+=>+m+%2B+(c+->+(m.getOrElse(c,+0)+%2B+1))+)
++}+++++++++++++++++++++++++++++++++++++++++++++++//>+woGetElse0Map:+(w:+forcomp.threadBug.Word)forcomp.threadBug.Occurrences

++def+woDeflt0Map(w:+Word):+Occurrences+=+{
++++++++val+map+=+Map[Char,+Int]().withDefaultValue(0)
++++++++w.foldLeft(map)((m,+c)+=>+m+%2B+(c+->+(m(c)+%2B+1))+)
++}+++++++++++++++++++++++++++++++++++++++++++++++//>+woDeflt0Map:+(w:+forcomp.threadBug.Word)forcomp.threadBug.Occurrences

++def+dfltHashMap(w:+Word):+Occurrences+=+{
++++++++val+map+=+scala.collection.immutable.HashMap[Char,+Int]().withDefaultValue(0)
++++++++w.foldLeft(map)((m,+c)+=>+m+%2B+(c+->+(m(c)+%2B+1))+)
++++}+++++++++++++++++++++++++++++++++++++++++++++//>+dfltHashMap:+(w:+forcomp.threadBug.Word)forcomp.threadBug.Occurrences

++++def+mmDef(w:+Word):+Occurrences+=+{
++++++++val+map+=+scala.collection.mutable.Map[Char,+Int]().withDefaultValue(0)
++++++++w.foldLeft(map)((m,+c)+=>+m+%2B=+(c+->+(m(c)+%2B+1))+)
++}+++++++++++++++++++++++++++++++++++++++++++++++//>+mmDef:+(w:+forcomp.threadBug.Word)forcomp.threadBug.Occurrences

++++val+functions+=+List("grp"+->+woGrouped+_,+"mtbl"+->+mmDef+_,+"else"+->+woGetElse0Map+_
++++,+"dfl0"+->+woDeflt0Map+_,+"hash"+->+dfltHashMap+_
++++)++++++++++++++++++++++++++++++++++//>+functions++:+List[(String,+String+=>+scala.collection.Map[Char,Int])]+=+Lis
++++++++++++++++++++++++++++++++++++++++++++++++++//%7C+t((grp,<function1>),+(mtbl,<function1>),+(else,<function1>),+(dfl0,<functio
++++++++++++++++++++++++++++++++++++++++++++++++++//%7C+n1>),+(hash,<function1>))


++++val+len+=+100+*+1000++++++++++++++++++++++//>+len++:+Int+=+100000
++++def+test(len:+Int)+{
++++++++val+data:+String+=+scala.util.Random.alphanumeric.take(len).toList.mkString
++++++++val+firstResult+=+functions.head._2(data)

++++++++def+run(f:+Word+=>+Occurrences):+Int+=+{
++++++++++++val+time1+=+System.currentTimeMillis()
++++++++++++val+result=+f(data)
++++++++++++val+time2+=+(System.currentTimeMillis()+-+time1)
++++++++++++assert(result.toSet+==+firstResult.toSet)
++++++++++++time2.toInt
++++++++}

++++++++def+log(results:+Seq[Int])+=+{
+++++++++++++++++((functions+zip+results)+map+{case+((title,+_),+r)+=>+title+%2B+"+"+%2B+r}+mkString+"+,+")
++++++++}

++++++++var+groupResults+=+List.fill(functions.length)(1)

++++++++val+integrals+=+for+(i+<-+(1+to+10))+yield+{
++++++++++++val+results+=+functions+map+(f+=>+(1+to+33).foldLeft(0)+((acc,_)+=>+run(f._2)))
++++++++++++println+(log+(results))
++++++++++++++++groupResults+=+(results+zip+groupResults)+map+{case+(r,+gr)+=>+r+%2B+gr}
++++++++++++++++log(groupResults).toUpperCase
++++++++}

++++++++integrals+foreach+println

++++}+++++++++++++++++++++++++++++++++++++++++//>+test:+(len:+Int)Unit


++++test(len)
++++test(len+*+2)
//+GRP+14+,+mtbl+11+,+else+31+,+dfl0+36+,+hash+34
//+GRP+91+,+MTBL+111

++++println("Done")
++++def+main(args:+Array[String])+{
++++}|code-block|syntax|javascript|523536|产生|523537|grp+5+,+mtbl+5+,+else+13+,+dfl0+17+,+hash+17
grp+3+,+mtbl+6+,+else+14+,+dfl0+16+,+hash+16
grp+3+,+mtbl+6+,+else+13+,+dfl0+17+,+hash+15
grp+4+,+mtbl+5+,+else+13+,+dfl0+15+,+hash+16
grp+23+,+mtbl+6+,+else+14+,+dfl0+15+,+hash+16
grp+5+,+mtbl+5+,+else+13+,+dfl0+16+,+hash+17
grp+4+,+mtbl+6+,+else+13+,+dfl0+16+,+hash+16
grp+4+,+mtbl+6+,+else+13+,+dfl0+17+,+hash+15
grp+3+,+mtbl+5+,+else+14+,+dfl0+16+,+hash+16
grp+3+,+mtbl+6+,+else+14+,+dfl0+16+,+hash+16
GRP+5+,+MTBL+5+,+ELSE+13+,+DFL0+17+,+HASH+17
GRP+8+,+MTBL+11+,+ELSE+27+,+DFL0+33+,+HASH+33
GRP+11+,+MTBL+17+,+ELSE+40+,+DFL0+50+,+HASH+48
GRP+15+,+MTBL+22+,+ELSE+53+,+DFL0+65+,+HASH+64
GRP+38+,+MTBL+28+,+ELSE+67+,+DFL0+80+,+HASH+80
GRP+43+,+MTBL+33+,+ELSE+80+,+DFL0+96+,+HASH+97
GRP+47+,+MTBL+39+,+ELSE+93+,+DFL0+112+,+HASH+113
GRP+51+,+MTBL+45+,+ELSE+106+,+DFL0+129+,+HASH+128
GRP+54+,+MTBL+50+,+ELSE+120+,+DFL0+145+,+HASH+144
GRP+57+,+MTBL+56+,+ELSE+134+,+DFL0+161+,+HASH+160
grp+7+,+mtbl+11+,+else+28+,+dfl0+31+,+hash+31
grp+7+,+mtbl+10+,+else+28+,+dfl0+32+,+hash+31
grp+7+,+mtbl+11+,+else+28+,+dfl0+31+,+hash+32
grp+7+,+mtbl+11+,+else+28+,+dfl0+31+,+hash+33
grp+7+,+mtbl+11+,+else+28+,+dfl0+32+,+hash+31
grp+8+,+mtbl+11+,+else+28+,+dfl0+31+,+hash+33
grp+8+,+mtbl+11+,+else+29+,+dfl0+38+,+hash+35
grp+7+,+mtbl+11+,+else+28+,+dfl0+32+,+hash+33
grp+8+,+mtbl+11+,+else+32+,+dfl0+35+,+hash+41
grp+7+,+mtbl+13+,+else+28+,+dfl0+33+,+hash+35
GRP+7+,+MTBL+11+,+ELSE+28+,+DFL0+31+,+HASH+31
GRP+14+,+MTBL+21+,+ELSE+56+,+DFL0+63+,+HASH+62
GRP+21+,+MTBL+32+,+ELSE+84+,+DFL0+94+,+HASH+94
GRP+28+,+MTBL+43+,+ELSE+112+,+DFL0+125+,+HASH+127
GRP+35+,+MTBL+54+,+ELSE+140+,+DFL0+157+,+HASH+158
GRP+43+,+MTBL+65+,+ELSE+168+,+DFL0+188+,+HASH+191
GRP+51+,+MTBL+76+,+ELSE+197+,+DFL0+226+,+HASH+226
GRP+58+,+MTBL+87+,+ELSE+225+,+DFL0+258+,+HASH+259
GRP+66+,+MTBL+98+,+ELSE+257+,+DFL0+293+,+HASH+300
GRP+73+,+MTBL+111+,+ELSE+285+,+DFL0+326+,+HASH+335
Done|523538|奇怪的是，最简洁的groupBy甚至比可变的map还要快！|523539|entityMap^0|12|7|0|0|0|0|9|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

It is interesting to note that the map with default 0 value, intentionally designed for this case demonstrates the worst performance (and not as concise as <code>groupBy</code>)

<pre><code> type Word = String
 type Sentence = Seq[Word]
 type Occurrences = scala.collection.Map[Char, Int]

 def woGrouped(w: Word): Occurrences = {
 w.groupBy(c =&gt; c).map({case (c, list) =&gt; (c -&gt; list.length)})
 } //&gt; woGrouped: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

 def woGetElse0Map(w: Word): Occurrences = {
 val map = Map[Char, Int]()
 w.foldLeft(map)((m, c) =&gt; m + (c -&gt; (m.getOrElse(c, 0) + 1)) )
 } //&gt; woGetElse0Map: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

 def woDeflt0Map(w: Word): Occurrences = {
 val map = Map[Char, Int]().withDefaultValue(0)
 w.foldLeft(map)((m, c) =&gt; m + (c -&gt; (m(c) + 1)) )
 } //&gt; woDeflt0Map: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

 def dfltHashMap(w: Word): Occurrences = {
 val map = scala.collection.immutable.HashMap[Char, Int]().withDefaultValue(0)
 w.foldLeft(map)((m, c) =&gt; m + (c -&gt; (m(c) + 1)) )
 } //&gt; dfltHashMap: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

 def mmDef(w: Word): Occurrences = {
 val map = scala.collection.mutable.Map[Char, Int]().withDefaultValue(0)
 w.foldLeft(map)((m, c) =&gt; m += (c -&gt; (m(c) + 1)) )
 } //&gt; mmDef: (w: forcomp.threadBug.Word)forcomp.threadBug.Occurrences

 val functions = List("grp" -&gt; woGrouped _, "mtbl" -&gt; mmDef _, "else" -&gt; woGetElse0Map _
 , "dfl0" -&gt; woDeflt0Map _, "hash" -&gt; dfltHashMap _
 ) //&gt; functions : List[(String, String =&gt; scala.collection.Map[Char,Int])] = Lis
 //| t((grp,&lt;function1&gt;), (mtbl,&lt;function1&gt;), (else,&lt;function1&gt;), (dfl0,&lt;functio
 //| n1&gt;), (hash,&lt;function1&gt;))


 val len = 100 * 1000 //&gt; len : Int = 100000
 def test(len: Int) {
 val data: String = scala.util.Random.alphanumeric.take(len).toList.mkString
 val firstResult = functions.head._2(data)

 def run(f: Word =&gt; Occurrences): Int = {
 val time1 = System.currentTimeMillis()
 val result= f(data)
 val time2 = (System.currentTimeMillis() - time1)
 assert(result.toSet == firstResult.toSet)
 time2.toInt
 }

 def log(results: Seq[Int]) = {
 ((functions zip results) map {case ((title, _), r) =&gt; title + " " + r} mkString " , ")
 }

 var groupResults = List.fill(functions.length)(1)

 val integrals = for (i &lt;- (1 to 10)) yield {
 val results = functions map (f =&gt; (1 to 33).foldLeft(0) ((acc,_) =&gt; run(f._2)))
 println (log (results))
 groupResults = (results zip groupResults) map {case (r, gr) =&gt; r + gr}
 log(groupResults).toUpperCase
 }

 integrals foreach println

 } //&gt; test: (len: Int)Unit


 test(len)
 test(len * 2)
// GRP 14 , mtbl 11 , else 31 , dfl0 36 , hash 34
// GRP 91 , MTBL 111

 println("Done")
 def main(args: Array[String]) {
 }
</code></pre>

produces

<pre><code>grp 5 , mtbl 5 , else 13 , dfl0 17 , hash 17
grp 3 , mtbl 6 , else 14 , dfl0 16 , hash 16
grp 3 , mtbl 6 , else 13 , dfl0 17 , hash 15
grp 4 , mtbl 5 , else 13 , dfl0 15 , hash 16
grp 23 , mtbl 6 , else 14 , dfl0 15 , hash 16
grp 5 , mtbl 5 , else 13 , dfl0 16 , hash 17
grp 4 , mtbl 6 , else 13 , dfl0 16 , hash 16
grp 4 , mtbl 6 , else 13 , dfl0 17 , hash 15
grp 3 , mtbl 5 , else 14 , dfl0 16 , hash 16
grp 3 , mtbl 6 , else 14 , dfl0 16 , hash 16
GRP 5 , MTBL 5 , ELSE 13 , DFL0 17 , HASH 17
GRP 8 , MTBL 11 , ELSE 27 , DFL0 33 , HASH 33
GRP 11 , MTBL 17 , ELSE 40 , DFL0 50 , HASH 48
GRP 15 , MTBL 22 , ELSE 53 , DFL0 65 , HASH 64
GRP 38 , MTBL 28 , ELSE 67 , DFL0 80 , HASH 80
GRP 43 , MTBL 33 , ELSE 80 , DFL0 96 , HASH 97
GRP 47 , MTBL 39 , ELSE 93 , DFL0 112 , HASH 113
GRP 51 , MTBL 45 , ELSE 106 , DFL0 129 , HASH 128
GRP 54 , MTBL 50 , ELSE 120 , DFL0 145 , HASH 144
GRP 57 , MTBL 56 , ELSE 134 , DFL0 161 , HASH 160
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 31
grp 7 , mtbl 10 , else 28 , dfl0 32 , hash 31
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 32
grp 7 , mtbl 11 , else 28 , dfl0 31 , hash 33
grp 7 , mtbl 11 , else 28 , dfl0 32 , hash 31
grp 8 , mtbl 11 , else 28 , dfl0 31 , hash 33
grp 8 , mtbl 11 , else 29 , dfl0 38 , hash 35
grp 7 , mtbl 11 , else 28 , dfl0 32 , hash 33
grp 8 , mtbl 11 , else 32 , dfl0 35 , hash 41
grp 7 , mtbl 13 , else 28 , dfl0 33 , hash 35
GRP 7 , MTBL 11 , ELSE 28 , DFL0 31 , HASH 31
GRP 14 , MTBL 21 , ELSE 56 , DFL0 63 , HASH 62
GRP 21 , MTBL 32 , ELSE 84 , DFL0 94 , HASH 94
GRP 28 , MTBL 43 , ELSE 112 , DFL0 125 , HASH 127
GRP 35 , MTBL 54 , ELSE 140 , DFL0 157 , HASH 158
GRP 43 , MTBL 65 , ELSE 168 , DFL0 188 , HASH 191
GRP 51 , MTBL 76 , ELSE 197 , DFL0 226 , HASH 226
GRP 58 , MTBL 87 , ELSE 225 , DFL0 258 , HASH 259
GRP 66 , MTBL 98 , ELSE 257 , DFL0 293 , HASH 300
GRP 73 , MTBL 111 , ELSE 285 , DFL0 326 , HASH 335
Done
</code></pre>

It is curious that most concise <code>groupBy</code> is faster than even mutable map!

blocks|key|524022|text|我没有使用length得到列表的大小，而是使用size作为一个，上面的答案建议它，因为报告了here的问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|524023|val+list+=+List("apple",+"oranges",+"apple",+"banana",+"apple",+"oranges",+"oranges")
list.groupBy(x=>x).map(t+=>+(t._1,+t._2.size))|code-block|syntax|javascript|524024|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/scala/collection-strawman/issues/146^0|5|6|N|4|1A|4|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

I did not get the size of the list using <code>length</code> but rather <code>size</code> as one the answer above suggested it because of the issue reported <a href="https://github.com/scala/collection-strawman/issues/146" rel="nofollow noreferrer">here</a>.

<pre><code>val list = List("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
list.groupBy(x=&gt;x).map(t =&gt; (t._1, t._2.size))
</code></pre>

blocks|key|307244|text|使用cats|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|307245|import+cats.implicits._

"Alphabet".toLowerCase().map(c+=>+Map(c+->+1)).toList.combineAll
"Alphabet".toLowerCase().map(c+=>+Map(c+->+1)).toList.foldMap(identity)|code-block|syntax|javascript|307246|entityMap|0|LINK|mutability|MUTABLE|url|https://typelevel.org/cats/^0|2|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

using <a href="https://typelevel.org/cats/" rel="nofollow noreferrer">cats</a>

<pre><code>import cats.implicits._

"Alphabet".toLowerCase().map(c =&gt; Map(c -&gt; 1)).toList.combineAll
"Alphabet".toLowerCase().map(c =&gt; Map(c -&gt; 1)).toList.foldMap(identity)
</code></pre>

blocks|key|307063|text|这是另一个选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|307064|scala>+val+list+=+List(1,2,4,2,4,7,3,2,4)
list:+List[Int]+=+List(1,+2,+4,+2,+4,+7,+3,+2,+4)

scala>+list.groupBy(x+=>+x)+map+{+case+(k,v)+=>+k->+v.length+}
res74:+scala.collection.immutable.Map[Int,Int]+=+Map(1+->+1,+2+->+3,+7+->+1,+3+->+1,+4+->+3)|code-block|syntax|javascript|307065|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|$]]

Here is another option:

<pre><code>scala&gt; val list = List(1,2,4,2,4,7,3,2,4)
list: List[Int] = List(1, 2, 4, 2, 4, 7, 3, 2, 4)

scala&gt; list.groupBy(x =&gt; x) map { case (k,v) =&gt; k-&gt; v.length }
res74: scala.collection.immutable.Map[Int,Int] = Map(1 -&gt; 1, 2 -&gt; 3, 7 -&gt; 1, 3 -&gt; 1, 4 -&gt; 3)
</code></pre>

blocks|key|307192|text|scala>+val+list+=+List(1,2,4,2,4,7,3,2,4)
list:+List[Int]+=+List(1,+2,+4,+2,+4,+7,+3,+2,+4)

scala>+println(list.filter(_+==+2).size)
3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|307193|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>scala&gt; val list = List(1,2,4,2,4,7,3,2,4)
list: List[Int] = List(1, 2, 4, 2, 4, 7, 3, 2, 4)

scala&gt; println(list.filter(_ == 2).size)
3
</code></pre>

blocks|key|524078|text|这里有一个非常简单的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|524079|val+data+=+List("it",+"was",+"the",+"best",+"of",+"times",+"it",+"was",+
+++++++++++++++++"the",+"worst",+"of",+"times")
data.foldLeft(Map[String,Int]().withDefaultValue(0)){
++case+(acc,+letter)+=>
++++acc+%2B+(letter+->+(1+%2B+acc(letter)))
}
//+=>+Map(worst+->+1,+best+->+1,+it+->+2,+was+->+2,+times+->+2,+of+->+2,+the+->+2)|code-block|syntax|javascript|524080|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|$]]

Here is a pretty easy way to do it.

<pre class="lang-scala prettyprint-override"><code>val data = List("it", "was", "the", "best", "of", "times", "it", "was", 
 "the", "worst", "of", "times")
data.foldLeft(Map[String,Int]().withDefaultValue(0)){
 case (acc, letter) =&gt;
 acc + (letter -&gt; (1 + acc(letter)))
}
// =&gt; Map(worst -&gt; 1, best -&gt; 1, it -&gt; 2, was -&gt; 2, times -&gt; 2, of -&gt; 2, the -&gt; 2)
</code></pre>

blocks|key|307300|text|val+words+=+Array("Mary",+"had",+"a",+"little",+"lamb",+"its"
++,+"fleece",+"was",+"white",+"as",+"snow",+"and",+"everywhere"
++,+"that",+"Mary",+"went",+"the",+"lamb",+"was",+"sure",+"to",+"go")


words.groupBy(_.length)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|307301|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>val words = Array(&quot;Mary&quot;, &quot;had&quot;, &quot;a&quot;, &quot;little&quot;, &quot;lamb&quot;, &quot;its&quot;
 , &quot;fleece&quot;, &quot;was&quot;, &quot;white&quot;, &quot;as&quot;, &quot;snow&quot;, &quot;and&quot;, &quot;everywhere&quot;
 , &quot;that&quot;, &quot;Mary&quot;, &quot;went&quot;, &quot;the&quot;, &quot;lamb&quot;, &quot;was&quot;, &quot;sure&quot;, &quot;to&quot;, &quot;go&quot;)


words.groupBy(_.length)
</code></pre>

<pre><code>val list = List(1,2,4,2,4,7,3,2,4)
</code></pre>

I want to implement it like this: <code>list.count(2)</code> (returns 3).

Scala how can I count the number of occurrences in a list

val list = List(1,2,4,2,4,7,3,2,4)我想像这样实现它：list.count(2) (返回3)。

问Scala如何计算列表中出现的次数
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala如何计算列表中出现的次数EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala如何计算列表中出现的次数
EN