12

Scala言語でファイル内の単語の出現をカウントするプログラムを最も簡単な方法でコーディングしようとしています。これまでのところ、次のコードがあります。

import scala.io.Codec.string2codec
import scala.io.Source
import scala.reflect.io.File

object WordCounter {
    val SrcDestination: String = ".." + File.separator + "file.txt"
    val Word = "\\b([A-Za-z\\-])+\\b".r

    def main(args: Array[String]): Unit = {

        val counter = Source.fromFile(SrcDestination)("UTF-8")
                .getLines
                .map(l => Word.findAllIn(l.toLowerCase()).toSeq)
                .toStream
                .groupBy(identity)
                .mapValues(_.length)

        println(counter)
    }
}

正規表現を気にしないでください。この行で取得されたシーケンスから単一の単語を抽出する方法を知りたい:

map(l => Word.findAllIn(l.toLowerCase()).toSeq)

各単語の出現回数をカウントするため。現在、カウントされた単語シーケンスでマップを取得しています。

4

5 に答える 5

37

ファイル行を正規表現で分割することにより、ファイル行を単語に変換できます"\\W+"（flatmapは遅延しているため、ファイル全体をメモリにロードする必要はありません）。出現回数をカウントするには、単語ごとに更新を折りたたむことができますMap[String, Int](を使用するよりもメモリと時間の効率が大幅に向上しますgroupBy) 。

scala.io.Source.fromFile("file.txt")
  .getLines
  .flatMap(_.split("\\W+"))
  .foldLeft(Map.empty[String, Int]){
     (count, word) => count + (word -> (count.getOrElse(word, 0) + 1))
  }
于 2013-03-18T22:03:40.357 に答える
16

以下が少し分かりやすいと思います。

Source.fromFile("file.txt").
  getLines().
  flatMap(_.split("\\W+")).
  toList.
  groupBy((word: String) => word).
  mapValues(_.length)
于 2013-08-17T22:01:20.783 に答える
1

私はあなたが何を求めているのか100％確信が持てませんが、私は問題を見ていると思います. flatMapの代わりに使用してみてくださいmap:

flatMap(l => Word.findAllIn(l.toLowerCase()).toSeq)

これにより、すべてのシーケンスが連結されるためgroupBy、行レベルではなく個々の単語に対して行われます。

正規表現に関するメモ

Regex について心配する必要はないとおっしゃっていたのは承知していますが、もう少し読みやすくするためにいくつかの変更を加えることができます。これがあなたが今持っているものです：

val Word = "\\b([A-Za-z\\-])+\\b".r

まず、バックスラッシュをエスケープする必要がないように、Scala のトリプル クォーテーションで囲まれた文字列を使用できます。

val Word = """\b([A-Za-z\-])+\b""".r

第 2 に、文字クラス-の先頭に the を配置した場合、エスケープする必要はありません。

val Word = """\b([-A-Za-z])+\b""".r
于 2013-03-18T22:03:47.843 に答える
0

これが私がしたことです。これにより、ファイルが切り刻まれます。Hashmap は、高いパフォーマンスを実現するための良い方法であり、どのような種類のものよりも優れています。あなたが見ることができるもっと簡潔なソートとスライス機能もあります。

import java.io.FileNotFoundException

/**.
 * Cohesive static method object for file handling.
 */
object WordCountFileHandler {

  val FILE_FORMAT = "utf-8"

  /**
   * Take input from file. Split on spaces.
   * @param fileLocationAndName string location of file
   * @return option of string iterator
   */
  def apply (fileLocationAndName: String) : Option[Iterator[String]] = {
    apply (fileLocationAndName, " ")
  }

  /**
   * Split on separator parameter.
   * Speculative generality :P
   * @param fileLocationAndName string location of file
   * @param wordSeperator split on this string
   * @return
   */
  def apply (fileLocationAndName: String, wordSeperator: String): Option[Iterator[String]] = {
    try{
      val words = scala.io.Source.fromFile(fileLocationAndName).getLines() //scala io.Source is a bit hackey. No need to close file.

      //Get rid of anything funky... need the double space removal for files like the README.md...
      val wordList = words.reduceLeft(_ + wordSeperator + _).replaceAll("[^a-zA-Z\\s]", "").replaceAll("  ", "").split(wordSeperator)
      //wordList.foreach(println(_))
      wordList.length match {
        case 0 => return None
        case _ => return Some(wordList.toIterator)
      }
    } catch {
      case _:FileNotFoundException => println("file not found: " + fileLocationAndName); return None
      case e:Exception => println("Unknown exception occurred during file handling: \n\n" + e.getStackTrace); return None
    }
  }
}

import collection.mutable

/**
 * Static method object.
 * Takes a processed map and spits out the needed info
 * While a small performance hit is made in not doing this during the word list analysis,
 * this does demonstrate cohesion and open/closed much better.
 * author: jason goodwin
 */
object WordMapAnalyzer {

  /**
   * get input size
   * @param input
   * @return
   */
  def getNumberOfWords(input: mutable.Map[String, Int]): Int = {
    input.size
  }

  /**
   * Should be fairly logarithmic given merge sort performance is generally about O(6nlog2n + 6n).
   * See below for more performant method.
   * @param input
   * @return
   */

  def getTopCWordsDeclarative(input: mutable.HashMap[String, Int], c: Int): Map[String, Int] = {
    val sortedInput = input.toList.sortWith(_._2 > _._2)
    sortedInput.take(c).toMap
  }

  /**
   * Imperative style is used here for much better performance relative to the above.
   * Growth can be reasoned at linear growth on random input.
   * Probably upper bounded around O(3n + nc) in worst case (ie a sorted input from small to high).
   * @param input
   * @param c
   * @return
   */
  def getTopCWordsImperative(input: mutable.Map[String, Int], c: Int): mutable.Map[String, Int] = {
    var bottomElement: (String, Int) = ("", 0)
    val topList = mutable.HashMap[String, Int]()

    for (x <- input) {
      if (x._2 >= bottomElement._2 && topList.size == c ){
        topList -= (bottomElement._1)
        topList +=((x._1, x._2))
        bottomElement = topList.toList.minBy(_._2)
      } else if (topList.size < c ){
        topList +=((x._1, x._2))
        bottomElement = topList.toList.minBy(_._2)
      }
    }
    //println("Size: " + topList.size)

    topList.asInstanceOf[mutable.Map[String, Int]]
  }
}

object WordMapCountCalculator {

  /**
   * Take a list and return a map keyed by words with a count as the value.
   * @param wordList List[String] to be analysed
   * @return HashMap[String, Int] with word as key and count as pair.
   * */

   def apply (wordList: Iterator[String]): mutable.Map[String, Int] = {
    wordList.foldLeft(new mutable.HashMap[String, Int])((word, count) => {
      word get(count) match{
        case Some(x) => word += (count -> (x+1))   //if in map already, increment count
        case None => word += (count -> 1)          //otherwise, set to 1
      }
    }).asInstanceOf[mutable.Map[String, Int]] 
}
于 2013-03-19T00:19:31.660 に答える