Pri*_*mar 1 java collections scala list
我正在尝试将数据写入 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 行相同的值（第一行值），列表中的值没有被迭代。
任何参考文献也会有帮助
如果没有完整的示例（如在编译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 中，通常认为首选不可变结构比可变结构更好。鉴于此，我建议您构建一个函数，使用不可变的方法将序列前缀添加到行中。有多种方法可以做到这一点，但最基本的方法是操作fold。如果您不熟悉它，fold可以将 a 视为对结构的转换，就像 for 循环的函数版本一样。
考虑到这一点，您可以采用以下方法获取一些行，这些行是 aList[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
AfoldLeft以与我们想要的相反的方式构建列表，这就是我.reverse在最后调用的原因。其原因是堆栈在遍历结构时如何工作的人为因素，超出了本问题的范围，但有很多关于为什么使用foldLeftor 的好文章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
}
)
让我们分解一下。我正在使用包Try中的数据类型scala.util。它与语言级try/catch/finally块类似，但它不使用特殊的构造来捕获异常，而是使用普通值。这是 Scala 中的另一个常见习惯用法，与特殊的语言控制流结构相比，更喜欢简单的语言值。
让我们仔细看看这个表达式(header +: rows).map(_.toArray).asJava。这个小表达式正在执行相当多的操作。首先，我们将行添加header到行列表的前面(header +: rows)。然后，由于CSVWriter需要 anIterable<Array<String>>我们首先将内部类型转换为 ，Array然后将外部类型转换为Iterable。调用.asJava是进行外部类型转换的，您可以通过导入来获取它scala.collection.JavaConverters._，它在 Scala 和 Java 类型之间进行隐式转换。
该函数的其余部分非常简单。我们写出行，然后检查是否出现故障。如果有，我们确保仍然尝试关闭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可以减轻这种情况。但是，除非确实需要，否则永远不应该进行这样的优化，因为它会使代码更容易出错且不太惯用（因此可读性较差）。