Question

我想以强类型方式访问scala中的csv文件。例如，当我读取csv的每一行时，它会自动解析并表示为具有适当类型的元组。我可以在传递给解析器的某种模式中预先指定类型。这样做是否存在任何库？如果没有，我怎么能自己实现这个功能呢？

Answer 1

product-collections似乎非常适合您的要求：

scala> val data = CsvParser[String,Int,Double].parseFile("sample.csv")
data: com.github.marklister.collections.immutable.CollSeq3[String,Int,Double] = 
CollSeq((Jan,10,22.33),
        (Feb,20,44.2),
        (Mar,25,55.1))

~~product-collections使用了opencsv。~~

CollSeq3是IndexedSeq[Product3[T1,T2,T3]]，还有Product3[Seq[T1],Seq[T2],Seq[T3]]，含糖量很少。我是product-collections的作者。

这是a link to the io page of the scaladoc

Product3本质上是一个arity 3的元组。

Answer 2

如果您的内容使用双引号括起其他双引号，逗号和换行符，我肯定会使用像opencsv这样的库来正确处理特殊字符。通常，您最终得到Iterator[Array[String]]。然后，您使用Iterator.map或collect将每个Array[String]转换为处理类型转换错误的元组。如果你需要处理输入而不加载所有内存，那么你继续使用迭代器，否则你可以转换为Vector或List并关闭输入流。

所以看起来像这样：

val reader = new CSVReader(new FileReader(filename))
val iter = reader.iterator()
val typed = iter collect {
  case Array(double, int, string) => (double.toDouble, int.toInt, string)
}
// do more work with typed
// close reader in a finally block

根据您需要处理错误的方式，您可以返回Left表示错误，Right表示成功元组可以将错误与正确的行分开。此外，我有时使用scala-arm来封闭所有这些以关闭资源。因此我的数据可能会包含在resource.ManagedResource monad中，以便我可以使用来自多个文件的输入。

最后，虽然您希望使用元组，但我发现通常更清楚的是有一个适合该问题的案例类，然后编写一个从Array[String]创建该案例类对象的方法。

Answer 3

由于CSV的重要引用规则，这比它应该更复杂。您可能应该从现有的CSV解析器开始，例如OpenCSV或其中一个名为scala-csv的项目。（有at least three。）

然后你最终得到了某种字符串集合的集合。如果您不需要快速读取大量CSV文件，您可以尝试将每一行解析为每种类型，并采取不引发异常的第一行。例如，

import scala.util._

case class Person(first: String, last: String, age: Int) {}
object Person {
  def fromCSV(xs: Seq[String]) = Try(xs match {
    case s0 +: s1 +: s2 +: more => new Person(s0, s1, s2.toInt)
  })
}

如果你确实需要相当快地解析它们并且你不知道可能存在什么，你应该对各个项目使用某种匹配（例如正则表达式）。无论哪种方式，如果有任何错误的机会，您可能希望使用Try或Option或某些包装错误。

Answer 4

我为Scala创建了一个强类型的CSV帮助程序，名为object-csv。它不是一个完全成熟的框架，但可以轻松调整。有了它，你可以这样做：

val peopleFromCSV = readCSV[Person](fileName)

Person是案例类，定义如下：

case class Person (name: String, age: Int, salary: Double, isNice:Boolean = false)

在GitHub或我的blog post中了解详情。

Answer 5

我建立了自己的想法，强烈地对最终产品进行强制转换，而不仅仅是阅读阶段本身......正如所指出的那样，可能会更好地处理像Apache CSV这样的第一阶段，第二阶段可能就是我所做的。这是您欢迎的代码。我们的想法是在构造时对类型为T的CSVReader [T]进行类型转换。您还必须为读者提供Type [T]的Factor对象。这里的想法是类本身（或者在我的示例中是辅助对象）决定构造细节，从而将其与实际读数分离。您可以使用Implicit对象来传递助手，但我在这里没有这样做。唯一的缺点是CSV的每一行必须具有相同的类类型，但您可以根据需要扩展此概念。

class CsvReader/**
 * @param fname
 * @param hasHeader : ignore header row
 * @param delim     : "\t" , etc     
 */

 [T] ( factory:CsvFactory[T], fname:String, delim:String) {

  private val f = Source.fromFile(fname)
  private var lines = f.getLines  //iterator
  private var fileClosed = false

  if (lines.hasNext) lines = lines.dropWhile(_.trim.isEmpty) //skip white space

  def hasNext = (if (fileClosed) false else lines.hasNext)

  lines = lines.drop(1) //drop header , assumed to exist


 /**
 * also closes the file 
 * @return the line
 */
def nextRow ():String = {  //public version
    val ans = lines.next
    if (ans.isEmpty) throw new Exception("Error in CSV, reading past end "+fname)
    if (lines.hasNext) lines = lines.dropWhile(_.trim.isEmpty) else close()

    ans 
  }

  //def nextObj[T](factory:CsvFactory[T]): T = past version

  def nextObj(): T = {  //public version

    val s = nextRow()
    val a = s.split(delim)        
    factory makeObj a
  }

  def allObj() : Seq[T] = {

    val ans = scala.collection.mutable.Buffer[T]()
    while (hasNext) ans+=nextObj()

    ans.toList
  }

  def close() = {
    f.close;
    fileClosed = true
  }

} //class

下一个示例Helper Factory和示例“Main”

trait CsvFactory[T] {  //handles all serial controls (in and out)   

  def makeObj(a:Seq[String]):T  //for reading 

  def makeRow(obj:T):Seq[String]//the factory basically just passes this duty 

  def header:Seq[String]    //must define headers for writing 
}



/**
 * Each class implements this as needed, so the object can be serialized by the writer
 */


case class TestRecord(val name:String, val addr:String, val zip:Int)  {

  def toRow():Seq[String] = List(name,addr,zip.toString) //handle conversion to CSV

}


object TestFactory extends CsvFactory[TestRecord] {

  def makeObj (a:Seq[String]):TestRecord =  new TestRecord(a(0),a(1),a(2).toDouble.toInt)
  def header = List("name","addr","zip")
  def makeRow(o:TestRecord):Seq[String] = {
    o.toRow.map(_.toUpperCase())
  }

}

object CsvSerial {

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

    val whereami = System.getProperty("user.dir")
    println("Begin CSV test in "+whereami) 

    val reader = new CsvReader(TestFactory,"TestCsv.txt","\t")


    val all = reader.allObj() //read the CSV info a file
    sd.p(all)
    reader.close

    val writer = new CsvWriter(TestFactory,"TestOut.txt", "\t")

    for (x<-all) writer.printObj(x)
    writer.close

  } //main  
}

示例CSV（如果从编辑器复制，可能需要修复选项卡

）

Name    Addr    Zip "Sanders, Dante R." 4823 Nibh Av.   60797.00 "Decker, Caryn G." 994-2552 Ac Rd. 70755.00 "Wilkerson, Jolene Z." 3613 Ultrices. St.  62168.00 "Gonzales, Elizabeth W."   "P.O. Box 409, 2319 Cursus. Rd."    72909.00 "Rodriguez, Abbot O."  Ap #541-9695 Fusce Street   23495.00 "Larson, Martin L."    113-3963 Cras Av.   36008.00 "Cannon, Zia U."   549-2083 Libero Avenue  91524.00 "Cook, Amena B."   Ap
#668-5982 Massa Ave 69205.00

最后是作者（注意工厂方法也需要这个“makerow”

import java.io._


    class CsvWriter[T] (factory:CsvFactory[T], fname:String, delim:String, append:Boolean = false) {

      private val out   = new PrintWriter(new BufferedWriter(new FileWriter(fname,append)));
      if (!append)  out.println(factory.header mkString delim )

      def flush() = out.flush()


      def println(s:String) =    out.println(s)

      def printObj(obj:T) =  println( factory makeRow(obj) mkString(delim) )
      def printAll(objects:Seq[T]) = objects.foreach(printObj(_))
      def close() = out.close

    }

Answer 6

您可以使用kantan.csv，它的设计正是为了这个目的。

想象一下，您有以下输入：

1,Foo,2.0
2,Bar,false

使用kantan.csv，您可以编写以下代码来解析它：

import kantan.csv.ops._

new File("path/to/csv").asUnsafeCsvRows[(Int, String, Either[Float, Boolean])](',', false)

你会得到一个迭代器，其中每个条目的类型为(Int, String, Either[Float, Boolean])。请注意CSV中最后一列可以是多种类型的位，但使用Either可以方便地处理。

这一切都以完全类型安全的方式完成，不涉及反射，在编译时验证。

根据您愿意去的兔子洞的距离，还有一个shapeless模块用于自动案例类和求和类型派生，以及对scalaz和{{3的支持类型和类型类。

完全披露：我是kantan.csv的作者。

Answer 7

如果您知道＃和字段类型，可能是这样的？：

case class Friend(id: Int, name: String) // 1,  Fred

val friends = scala.io.Source.fromFile("friends.csv").getLines.map { line =>
   val fields = line.split(',')
   Friend(fields(0).toInt, fields(1))
}

scala中对csv的强类型访问？

7 个答案: