如何在scala中写入csv文件？

Question

我试图将数据写入csv文件，我创建了四列作为

val csvFields = Array("Serial Number", "Record Type", First File value", Second file value") ', 

除了序列号，其他三个字段是列表

Second_file_value = List ("B", "gjgbn", "fgbhjf", "dfjf")

First_File_Value=List（“A”、“abhc”、“agch”、“mknk”）

Record_type=List（'1'，'2'，3'，'4'）

 val outputFile = new BufferedWriter(new FileWriter("Resulet.csv")
 val csvWriter = new CSVWriter(outputFile)
 val listOfRecords = new ListBuffer[Array[String]]()
 listOfRecords :+ csvFields

我使用这个循环写入列

for ( i <- 1 until 30){
listOfRecords += Array(i.toString, Record_type , First_File_Value , Second_file_value )}
csvWriter.writeAll(listOfRecords.toList)
output.close()

我面临的问题是csv文件填充了30行相同的值（第一行值），列表中的值没有被迭代。

任何参考资料也会有所帮助




Answer 1

如果没有完整的示例（如在编译Main文件中），就无法解释为什么一遍又一遍地得到同一行。你发布的代码片段单独来看是正确的。

scala> val lb: ListBuffer[Array[String]] = new ListBuffer[Array[String]]()
lb: scala.collection.mutable.ListBuffer[Array[String]] = ListBuffer()

scala> for (i <- 1 until 30){lb += Array(i.toString)}

scala> lb.toList
res5: List[Array[String]] = List(Array(1), Array(2), Array(3), Array(4), Array(5), Array(6), Array(7), Array(8), Array(9), Array(10), Array(11), Array(12), Array(13), Array(14), Array(15), Array(16), Array(17), Array(18), Array(19), Array(20), Array(21), Array(22), Array(23), Array(24), Array(25), Array(26), Array(27), Array(28), Array(29))

但是，通常有许多方法可以更好地做到这一点，这可能会帮助您避免此错误和其他错误。

在Scala中，人们普遍认为，作为一种习语，不可变结构比可变结构更受欢迎。鉴于此，我建议您构造一个函数，使用不可变的方法将序列前缀添加到行中。有很多方法可以做到这一点，但最基本的方法是折叠操作。如果您不熟悉它，折叠可以被认为是结构上的转换，比如for循环的功能版本。

考虑到这一点，下面是如何获取一些行，这些行是一个列表[List[String]]，并为所有行添加一个数字前缀。

def addPrefix(lls: List[List[String]]): List[List[String]] =
  lls.foldLeft((1, List.empty[List[String]])){
    // You don't need to annotate the types here, I just did that for clarity.
    case ((serial: Int, acc: List[List[String]]), value: List[String]) =>
      (serial + 1, (serial.toString +: value) +: acc)
  }._2.reverse

一个foldLeft建立的列表与我们想要的相反，这就是为什么我称之为。在结尾处反转。这是因为堆栈在遍历结构时如何工作，这超出了这个问题的范围，但是有很多关于为什么使用foldLeft或foldRight的好文章。

从我上面读到的内容来看，这就是示例中的行。

val columnOne: List[String] =
  List('1','2','3','4').map(_.toString)
val columnTwo: List[String] =
  List("A","abhc","agch","mknk")
val columnThree: List[String] =
  List("B", "gjgbn", "fgbhjf", "dfjf")

val rows: List[List[String]] =
  columnOne.zip(columnTwo.zip(columnThree)).foldLeft(List.empty[List[String]]){
    case (acc, (a, (b, c))) => List(a, b, c) +: acc
  }.reverse

这就产生了这个。

scala> rows.foreach(println)
List(1, A, B)
List(2, abhc, gjgbn)
List(3, agch, fgbhjf)
List(4, mknk, dfjf)

让我们尝试用它作为输入调用我们的函数。

scala> addPrefix(rows).foreach(println)
List(1, 1, A, B)
List(2, 2, abhc, gjgbn)
List(3, 3, agch, fgbhjf)
List(4, 4, mknk, dfjf)

好的，看起来不错。

现在来编写CSV文件。因为CSVWriter适用于Java集合类型，所以我们需要将我们的Scala类型转换为Java集合。在Scala中，您应该在最后一刻这样做。这样做的原因是Scala的类型旨在与Scala很好地配合使用，我们不想过早失去这种能力。在不变性方面，它们也比并行Java类型更安全（如果您使用的是不可变变体，本示例就是这样）。

让我们定义一个函数writeCsvFile，它获取文件名、标题行和行列表并将其写出。同样，有很多方法可以正确做到这一点，但这里有一个简单的例子。

def writeCsvFile(
  fileName: String,
  header: List[String],
  rows: List[List[String]]
): Try[Unit] =
  Try(new CSVWriter(new BufferedWriter(new FileWriter(fileName)))).flatMap((csvWriter: CSVWriter) =>
    Try{
      csvWriter.writeAll(
        (header +: rows).map(_.toArray).asJava
      )
      csvWriter.close()
    } match {
      case f @ Failure(_) =>
        // Always return the original failure.  In production code we might
        // define a new exception which wraps both exceptions in the case
        // they both fail, but that is omitted here.
        Try(csvWriter.close()).recoverWith{
          case _ => f
        }
      case success =>
        success
    }
  )

让我们把它分解一下。我使用的是scala.util包中的try数据类型。它类似于语言级别的try/catch/last块，但不是使用特殊构造来捕获异常，而是使用正常值。这是Scala中的另一个常见习语，更喜欢普通语言值而不是特殊语言控制流构造。

让我们仔细看看这个表达式（标题：行）。地图（toArray）。asJava。这个小表达式正在执行许多操作。首先，我们将标题行添加到行列表的前面（标题：行）。然后，由于CSVWriter想要一个Iterable

函数的其余部分非常简单。我们把行写出来，然后检查是否有故障。如果有，我们确保仍然尝试关闭CSVWriter。

我在这里包含了一个完整的编译示例。

import com.opencsv._
import java.io._
import scala.collection.JavaConverters._
import scala.util._

object Main {

  val header: List[String] =
    List("Serial Number", "Record Type", "First File value", "Second file value")

  val columnOne: List[String] =
    List('1','2','3','4').map(_.toString)
  val columnTwo: List[String] =
    List("A","abhc","agch","mknk")
  val columnThree: List[String] =
    List("B", "gjgbn", "fgbhjf", "dfjf")

  val rows: List[List[String]] =
    columnOne.zip(columnTwo.zip(columnThree)).foldLeft(List.empty[List[String]]){
      case (acc, (a, (b, c))) => List(a, b, c) +: acc
    }.reverse

  def addPrefix(lls: List[List[String]]): List[List[String]] =
    lls.foldLeft((1, List.empty[List[String]])){
      case ((serial: Int, acc: List[List[String]]), value: List[String]) =>
        (serial + 1, (serial.toString +: value) +: acc)
    }._2.reverse

  def writeCsvFile(
    fileName: String,
    header: List[String],
    rows: List[List[String]]
  ): Try[Unit] =
    Try(new CSVWriter(new BufferedWriter(new FileWriter(fileName)))).flatMap((csvWriter: CSVWriter) =>
      Try{
        csvWriter.writeAll(
          (header +: rows).map(_.toArray).asJava
        )
        csvWriter.close()
      } match {
        case f @ Failure(_) =>
          // Always return the original failure.  In production code we might
          // define a new exception which wraps both exceptions in the case
          // they both fail, but that is omitted here.
          Try(csvWriter.close()).recoverWith{
            case _ => f
          }
        case success =>
          success
      }
    )

  def main(args: Array[String]): Unit = {
    println(writeCsvFile("/tmp/test.csv", header, addPrefix(rows)))
  }
}

这是运行该程序后文件的内容。

"Serial Number","Record Type","First File value","Second file value"
"1","1","A","B"
"2","2","abhc","gjgbn"
"3","3","agch","fgbhjf"
"4","4","mknk","dfjf"

我在原始帖子的评论中注意到您正在使用"au.com.bytecode"%"opencsv"%"2.4"。一般来说，我不熟悉opencsv库，但根据Maven Central的说法，这似乎是主存储库的一个非常古老的分支。我建议您使用主存储库。https://search.maven.org/search?q=opencsv

人们经常担心，当使用不变的数据结构和技术时，我们需要进行性能权衡。情况可能是这样，但通常渐近复杂性不变。上面的解决方案是O（n），其中n是行数。它有一个比可变解更高的常数，但通常这并不重要。如果是的话，可以采用一些技术，比如addPrefix中更显式的递归来缓解这种情况。然而，除非你真的需要，否则你永远不应该这样优化，因为这样会使代码更容易出错，更不惯用（因此可读性也更低）。