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

99 
val list = List(1,2,4,2,4,7,3,2,4)

我想这样实现：（list.count(2)返回3）。

scala 
— 胆小鬼
source
我不知道是否有适当的方法来获取scala中列表的大小，但是对于您的情况，您可以使用序列。
— Qusay Fantazia
这个问题仍然没有答案吗？问，因为您可能已经忘记接受一个。
— Tobias Kolb，

Answers:

150

其他答案之一的较简洁版本是：

val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")

s.groupBy(identity).mapValues(_.size)

给出Map原始序列中每个项目的计数：

Map(banana -> 1, oranges -> 3, apple -> 3)

该问题询问如何查找特定项目的计数。使用这种方法，解决方案将需要将所需元素映射到其计数值，如下所示：

s.groupBy(identity).mapValues(_.size)("apple")
— 奥鲁努鲁斯
source
2
什么是“身份”？
— Igorock '16
4
它是身份的功能，如讨论在这里。该函数groupBy需要一个适用于元素的函数，因此它知道如何对其进行分组。例如，可以按照答案的长度（groupBy(_.size)）或首字母（groupBy(_.head)）对答案中的字符串进行身份分组。
— ohruunuruus
2
缺点是创建了很多无用的集合（因为只需要大小）。
— Yann Moisan
如果我想在该表达式中定义一个累加器映射而不是创建一个新映射怎么办？
— Tobias Kolb，
128

Scala集合确实具有count：list.count(_ == 2)

— 谢飞
source
48

我遇到了与Sharath Prabhal相同的问题，并且得到了另一个（对我来说更清楚）的解决方案：

val s = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
s.groupBy(l => l).map(t => (t._1, t._2.length))

结果：

Map(banana -> 1, oranges -> 3, apple -> 3)
— 科威
source
44
稍微干净一点的版本是s.groupBy(identity).mapValues(_.size)
— ohruunuruus 2015年
1
@ohruunuruus这应该是一个答案（vs评论）；如果可以的话，我很乐意投票（如果我是OP，则选择它为最佳答案）；
— doug 2015年
1
@doug对SO有点陌生，不确定，但很乐意
— ohruunuruus
27 
list.groupBy(i=>i).mapValues(_.size)

给

Map[Int, Int] = Map(1 -> 1, 2 -> 3, 7 -> 1, 3 -> 1, 4 -> 3)

请注意，您可以更换 (i=>i)用内置identity函数：

list.groupBy(identity).mapValues(_.size)
— Noego
source
喜欢使用内置库的简短解决方案
— Rustam Aliyev，
14 
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))
— 安德烈亚斯·谢纳特（AndreasScheinert）
source
1
但它产生数字。每个值的出现次数是该值出现的次数，似乎效率很低，但不是很有用...
— Erik Kaplun 2013年
13

从开始Scala 2.13，groupMapReduce方法可以一次遍历列表：

// val seq = Seq("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
seq.groupMapReduce(identity)(_ => 1)(_ + _)
// immutable.Map[String,Int] = Map(banana -> 1, oranges -> 3, apple -> 3)
seq.groupMapReduce(identity)(_ => 1)(_ + _)("apple")
// Int = 3

这个：

  • group上榜元件（的组部分组的MapReduce）

  • map将每个分组值出现的次数设为1（组Map Reduce的映射部分）

  • reduce一组值（_ + _）中的s个值相加（减少groupMap Reduce的一部分）。

这是可以翻译的单次通过版本：

seq.groupBy(identity).mapValues(_.map(_ => 1).reduce(_ + _))
— Xavier Guihot
source
很好，这就是我一直在寻找的东西，我感到很难过，即使Java流（在某些方面不好）也允许一次通过此操作，而Scala不能。
— Dici
8

我遇到了同样的问题，但想一次性计算多个项目。

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

https://gist.github.com/sharathprabhal/6890475

— Sharath Prabhal
source
也许使用Stream和接受的答案将使您的目标“一次性完成”，并提供更清晰的代码。
— juanchito
此解决方案使用groupBy仅对List进行一次迭代，然后map将对其进行两次。
— ruloweb
7

如果要使用它list.count(2)，就必须使用Implicit Class来实现它。

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
— 卢塞纳
source
7

简短答案：

import scalaz._, Scalaz._
xs.foldMap(x => Map(x -> 1))

长答案：

使用Scalaz，给出。

import scalaz._, Scalaz._

val xs = List('a, 'b, 'c, 'c, 'a, 'a, 'b, 'd)

然后所有这些（从简化程度到简化程度的顺序）

xs.map(x => Map(x -> 1)).foldMap(identity)
xs.map(x => Map(x -> 1)).foldMap()
xs.map(x => Map(x -> 1)).suml
xs.map(_ -> 1).foldMap(Map(_))
xs.foldMap(x => Map(x -> 1))

让

Map('b -> 2, 'a -> 3, 'c -> 2, 'd -> 1)
— 埃里克·卡普伦
source
6

有趣的是，针对这种情况故意设计的默认值为0的地图展示了最差的性能（并且不如简洁groupBy）

    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 + (c -> (m.getOrElse(c, 0) + 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 + (c -> (m(c) + 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 + (c -> (m(c) + 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 += (c -> (m(c) + 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
                                                  //| t((grp,<function1>), (mtbl,<function1>), (else,<function1>), (dfl0,<functio
                                                  //| 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 + " " + 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 + 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]) {
    }

产生

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

奇怪的是，最简洁的groupBy地图甚至比可变地图还快！

— 值
source
3
我对此基准有点怀疑，因为尚不清楚数据的大小。该groupBy解决方案执行a，toLower而其他解决方案则不执行。还有为什么要对地图使用模式匹配-只需使用mapValues。因此，将其组合在一起，您将获得def woGrouped(w: Word): Map[Char, Int] = w.groupBy(identity).mapValues(_.size)-尝试一下并检查各种尺寸列表的性能。最后，在其他解决方案中，为什么a）声明mapb）将其设为var？只要做到w.foldLeft(Map.empty[Char, Int])...
— samthebest
1
感谢您提供更多数据（更改了我的投票：）。我认为为什么groupBy的实现使用了Builders 的可变映射，该映射针对迭代增量进行了优化。然后，使用转换可变映射为不可变MapBuilder。可能还会进行一些惰性评估，以加快处理速度。
— samthebest 2014年
@samthebest您只需查找计数器并增加它。我看不到那里可以缓存什么。无论如何，缓存必须是相同类型的映射。
— 2014年
我并不是说它可以缓存任何内容。我想象性能的提高来自于Builders 的使用，可能还有些懒惰的评估。
— samthebest 2014年
@samthebest惰性评估=延迟评估（按名称调用）+缓存。您不能谈论懒惰的评估，但不能谈论缓存。
— 2014年
4

我没有使用来得到列表的大小，length而是size因为这里报告了问题，所以上面的答案建议使用它。

val list = List("apple", "oranges", "apple", "banana", "apple", "oranges", "oranges")
list.groupBy(x=>x).map(t => (t._1, t._2.size))
— 教育
source
3

这是另一个选择：

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)
— 阿卡瓦尔
source
3 
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
— 巴鲁
source
3

用猫

import cats.implicits._

"Alphabet".toLowerCase().map(c => Map(c -> 1)).toList.combineAll
"Alphabet".toLowerCase().map(c => Map(c -> 1)).toList.foldMap(identity)
— 谢尔盖·舍夫奇克（Sergii Shevchyk）
source
2
哇，原始序列有4次迭代！甚至seq.groupBy(identity).mapValues(_.size)只经历两次。
— 武器等级
对于像“字母”这样的小字符串，迭代次数可能无关紧要，但是当处理集合中的数百万个项目时，迭代当然很重要！
— 武器等级
2

试试这个，应该可以。

val list = List(1,2,4,2,4,7,3,2,4)
list.count(_==2)

它将返回3

— dcripse数据
source
这与七年前谢飞给出的答案有何不同？
— jwvh
0

这是一种非常简单的方法。

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 + (letter -> (1 + acc(letter)))
}
// => Map(worst -> 1, best -> 1, it -> 2, was -> 2, times -> 2, of -> 2, the -> 2)
— 吉姆·牛顿
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.