在Scala中读取整个文件？

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

我能想到的最好的是：

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

还是我应该使用Java令人敬畏的惯用法之一，最好的用法是（不使用外部库）：

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()

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"

只是为了扩展Daniel的解决方案，您可以通过将以下导入插入到任何需要文件操作的文件中来极大地简化事情：

import scala.io.Source._

这样，您现在可以执行以下操作：

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

我会警惕将整个文件读入一个文件中String。这是一个非常不好的习惯，一个习惯会比您想像的要早，更难地咬您。该getLines方法返回type的值Iterator[String]。它实际上是文件中的惰性游标，使您可以检查所需的数据而不会冒内存过多的风险。

哦，并且回答您暗含的问题Source：是的，它是规范的I / O库。大多数代码java.io由于其较低级别的界面以及与现有框架的更好兼容性而最终使用，但是任何可以选择的代码都应使用Source，尤其是对于简单的文件操作。

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

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

使用中继线：

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

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

new String(Files.readAllBytes(Paths.get("file.txt")), UTF_8)

控制字符编码，没有资源可清理。此外，可能会进行优化（例如，Files.readAllBytes分配适合文件大小的字节数组）。

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

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

在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)
}

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

在不将内容加载到内存的情况下处理文件的多种方法：

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")

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

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

另外，这里的许多答案都忘记了Charset。最好始终明确提供它，否则它将一天之内。

为了模拟打开和读取文件的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

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

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

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

import scalax.file.Path

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

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

您还可以包括终结符，但默认情况下将其设置为false。

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

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

注意Source.scala。有关进一步的讨论，请参见Scala快速文本文件读取并上传到内存。

您无需解析每一行，然后再次将它们串联起来...

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
}

如果您不介意第三方依赖性，则应考虑使用OS-Lib库。这使得读取/写入文件和使用文件系统非常方便：

// 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")

使用单行助手来读取字节，读取块，读取行以及许多其他有用/通用的操作

显而易见的问题是“为什么要读取整个文件？” 如果文件很大，这显然不是可伸缩的解决方案。该scala.io.Source给你回一个Iterator[String]从getLines方法，这是非常有用的，简洁。

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

打印每一行，就像使用Java BufferedReader读取每行一样，并打印它：

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

当量：

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

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

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