在 Scala 中读取整个文件？

Question

在 Scala 中将整个文件读入内存的简单而规范的方法是什么？ （理想情况下，可以控制字符编码。）

我能想到的最好的是：

scala.io.Source.fromPath("file.txt").getLines.reduceLeft(_+_)

或者我应该使用Java's god-awful idioms 之一，其中最好的（不使用外部库）似乎是：

import java.util.Scanner
import java.io.File
new Scanner(new File("file.txt")).useDelimiter("\\Z").next()

通过阅读邮件列表讨论，我不清楚 scala.io.Source 是否应该是规范的 I/O 库。我不明白它的预期目的究竟是什么。

...我想要一些简单易记的东西。例如，在这些语言中，很难忘记成语...

Ruby    open("file.txt").read
Ruby    File.read("file.txt")
Python  open("file.txt").read()

Answer 1

val lines = scala.io.Source.fromFile("file.txt").mkString

顺便说一句，“scala.”并不是必需的，因为它始终在范围内，当然，您可以全部或部分导入 io 的内容，而不必在前面加上“io”。也是。

但是，以上内容使文件处于打开状态。为避免出现问题，您应该像这样关闭它：

val source = scala.io.Source.fromFile("file.txt")
val lines = try source.mkString finally source.close()

上面代码的另一个问题是，由于其实现性质，它非常慢。对于较大的文件，应该使用：

source.getLines mkString "\n"

Answer 2

// for file with utf-8 encoding
val lines = scala.io.Source.fromFile("file.txt", "utf-8").getLines.mkString

Answer 3

显而易见的问题是“你为什么要读取整个文件？”如果你的文件变得非常大，这显然不是一个可扩展的解决方案。 scala.io.Source 会从getLines 方法中返回一个Iterator[String]，它非常有用且简洁。

使用底层 java IO 实用程序将File、Reader 或InputStream 转换为String 来进行隐式转换并不是一件容易的事。我认为缺乏可扩展性意味着他们不将其添加到标准 API 是正确的。

Answer 4

只是为了扩展 Daniel 的解决方案，您可以通过将以下导入插入到任何需要文件操作的文件中来大大缩短时间：

import scala.io.Source._

有了这个，你现在可以做：

val lines = fromFile("file.txt").getLines

我会警惕将整个文件读入单个String。这是一个非常坏的习惯，它会比你想象的更快更狠地咬你。 getLines 方法返回 Iterator[String] 类型的值。它实际上是文件中的一个惰性光标，允许您只检查所需的数据，而不会冒内存过剩的风险。

哦，回答您关于 Source 的隐含问题：是的，它是规范的 I/O 库。大多数代码最终都使用java.io，因为它具有较低级别的接口和与现有框架更好的兼容性，但任何可以选择的代码都应该使用Source，特别是对于简单的文件操作。

Answer 5

有人告诉我 Source.fromFile 有问题。就个人而言，我在使用 Source.fromFile 打开大文件时遇到了问题，不得不求助于 Java InputStreams。

另一个有趣的解决方案是使用 scalax。下面是一些注释良好的代码示例，这些代码使用 ManagedResource 打开日志文件以使用 scalax 帮助程序打开文件：http://pastie.org/pastes/420714

Answer 6

（编辑：这在 scala 2.9 中不起作用，也可能在 2.8 中也不起作用）

使用主干：

scala> io.File("/etc/passwd").slurp
res0: String = 
##
# User Database
# 
... etc

Answer 7

正如一些人提到的scala.io.Source，由于连接泄漏，最好避免使用。

在新的孵化器项目（即 scala-io）被合并之前，可能 scalax 和纯 java 库（如 commons-io）是最佳选择。

Answer 8

在 scala.io.Source 上使用 getLines() 会丢弃用于行终止符的字符（\n、\r、\r\n 等）

以下内容应逐个字符地保留它，并且不会进行过多的字符串连接（性能问题）：

def fileToString(file: File, encoding: String) = {
  val inStream = new FileInputStream(file)
  val outStream = new ByteArrayOutputStream
  try {
    var reading = true
    while ( reading ) {
      inStream.read() match {
        case -1 => reading = false
        case c => outStream.write(c)
      }
    }
    outStream.flush()
  }
  finally {
    inStream.close()
  }
  new String(outStream.toByteArray(), encoding)
}

Answer 9

打印每一行，比如使用 Java BufferedReader 读取每一行，然后打印：

scala.io.Source.fromFile("test.txt" ).foreach{  print  }

等效：

scala.io.Source.fromFile("test.txt" ).foreach( x => print(x))

Answer 10

您还可以使用 scala io 中的 Path 来读取和处理文件。

import scalax.file.Path

现在您可以使用以下方法获取文件路径：-

val filePath = Path("path_of_file_to_b_read", '/')
val lines = file.lines(includeTerminator = true)

您也可以包含终止符，但默认设置为 false..

Answer 11

为了更快地整体读取/上传（大）文件，请考虑增加bufferSize 的大小（Source.DefaultBufSize 设置为2048），例如如下，

val file = new java.io.File("myFilename")
io.Source.fromFile(file, bufferSize = Source.DefaultBufSize * 2)

注意Source.scala。如需进一步讨论，请参阅Scala fast text file read and upload to memory。

Answer 12

就像在 Java 中一样，使用 CommonsIO 库：

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

此外，这里的许多答案都忘记了字符集。最好总是明确地提供它，否则它有一天会发生。

Answer 13

为了模拟打开和读取文件的 Ruby 语法（并传达语义），请考虑这个隐式类（Scala 2.10 及更高版本），

import java.io.File

def open(filename: String) = new File(filename)

implicit class RichFile(val file: File) extends AnyVal {
  def read = io.Source.fromFile(file).getLines.mkString("\n")
}

这样，

open("file.txt").read

Answer 14

还有一个：https://github.com/pathikrit/better-files#streams-and-codecs

在不将内容加载到内存的情况下 slurp 文件的各种方法：

val bytes  : Iterator[Byte]            = file.bytes
val chars  : Iterator[Char]            = file.chars
val lines  : Iterator[String]          = file.lines
val source : scala.io.BufferedSource   = file.content 

您也可以为任何读/写操作提供自己的编解码器（如果您不提供，则假定为 scala.io.Codec.default）：

val content: String = file.contentAsString  // default codec
// custom codec:
import scala.io.Codec
file.contentAsString(Codec.ISO8859)
//or
import scala.io.Codec.string2codec
file.write("hello world")(codec = "US-ASCII")

Answer 15

您不需要解析每一行然后再次连接它们......

Source.fromFile(path)(Codec.UTF8).mkString

我更喜欢用这个：

import scala.io.{BufferedSource, Codec, Source}
import scala.util.Try

def readFileUtf8(path: String): Try[String] = Try {
  val source: BufferedSource = Source.fromFile(path)(Codec.UTF8)
  val content = source.mkString
  source.close()
  content
}

Answer 16

Java 8+

import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Paths}

val path = Paths.get("file.txt")
new String(Files.readAllBytes(path), StandardCharsets.UTF_8)

Java 11+

import java.nio.charset.StandardCharsets
import java.nio.file.{Files, Path}

val path = Path.of("file.txt")
Files.readString(path, StandardCharsets.UTF_8)

这些提供对字符编码的控制，并且无需清理资源。由于更有效的分配模式，它也比其他模式（例如getLines().mkString("\n")）更快。

Answer 17

import scala.io.source
object ReadLine{
def main(args:Array[String]){
if (args.length>0){
for (line <- Source.fromLine(args(0)).getLine())
println(line)
}
}

在参数中你可以给出文件路径，它将返回所有行

Answer 18

如果你不介意第三方依赖，你应该考虑使用我的OS-Lib library。这使得读/写文件和使用文件系统非常方便：

// Make sure working directory exists and is empty
val wd = os.pwd/"out"/"splash"
os.remove.all(wd)
os.makeDir.all(wd)

// Read/write files
os.write(wd/"file.txt", "hello")
os.read(wd/"file.txt") ==> "hello"

// Perform filesystem operations
os.copy(wd/"file.txt", wd/"copied.txt")
os.list(wd) ==> Seq(wd/"copied.txt", wd/"file.txt")

为reading bytes、reading chunks、reading lines 和许多其他有用/常见操作提供单行帮助程序

Answer 19

你可以使用

Source.fromFile(fileName).getLines().mkString

但是应该注意 getLines() 会删除所有换行符。 如果你想保存格式，你应该使用

Source.fromFile(fileName).iter.mkString