Scala-文件操作

• 一、遍历一个文件中的每一行

• 方法一: 使用Source.getLines返回的迭代器

• 方法二: 将Source.getLines返回的迭代器，转换成数组

• 方法三: 调用Source.mkString，返回文本中所有的内容

• 二、遍历一个文件中的每一个字符

• 三、从URL以及字符串中读取字符

• 四、结合Java IO流，读取任意文件

• 4.1 结合Java IO流，写文件

• 4.2 递归遍历子目录

• 访问目录：

• 4.3 序列化以及反序列化（Java序列化和反序列化机制）

• 五、控制台输入

• 六、读取字符

• 七、读取词法单元或数字

• 八、从URL或其它资源读取

• 九、读取二进制文件

• 十、RandomAccessFile

---

---

相关内容原文地址：

简书：SunnyMore：Scala文件操作详解

CSDN：残缺的孤独：Scala 文件读写及Scala控制台输入

CSDN：power0405hf：Scala 文件操作

博客园：飞末：scala2.11读取文件

---

---

一、遍历一个文件中的每一行

必须导入scala.io.Source类: import scala.io.Source

import scala.io.Source
val source = Source.fromFile("myfile.txt", "UTF-8")
val lineIterator = source.getLines
val lines1 =lineIterator.toArray
val lines2 = lineIterator.toBuffer
//将文件内容读成字符串
val lines = source.mkString
source.close


val source = Source.fromFile("C://Users//Administrator//Desktop//test.txt", "UTF-8")
val lineIterator = source.getLines
for (line <- lineIterator) println(line)


println("读取本地文件：")
val localfile = Source.fromFile("D:\\ww\\test.txt","GBK") //中文乱码
for(line <- localfile.getLines()){
  println(line)
}
localfile.close()

一个BufferedSource对象的getLines方法，只能调用一次，一次调用完之后，遍历了迭代器里所有的内容，就已经把文件里的内容读取完了

如果反复调用source.getLines，是获取不到内容的

此时，必须重新创建一个BufferedSource对象

val source = Source.fromFile("C://Users//Administrator//Desktop//test.txt", "UTF-8")
val lines = source.getLines.toArray
for(line <- lines) println(line)


val source = Source.fromFile("C://Users//Administrator//Desktop//test.txt", "UTF-8")
val lines = source.mkString

二、遍历一个文件中的每一个字符

使用完BufferedSource对象之后，调用BufferedSource.close方法，关闭IO流资源。

BufferedSource，也实现了一个Iterator[Char]的这么一个trait。

val source = Source.fromFile("C://Users//Administrator//Desktop//test.txt", "UTF-8")
for(c <- source) print(c)

三、从URL以及字符串中读取字符

val source = Source.fromURL("http://www.baidu.com", "UTF-8")
val source = Source.fromString("Hello World")

四、结合Java IO流，读取任意文件

spark的源码是由scala和java共同编写而成的，Java的多线程

scala，本身的编程语言的功能，就不是特别的强大和完善，比如说，scala甚至不能很方便地写文件，必须依赖于java的io流才可以

所以说，scala，其实主要就是针对某些特定领域的一些复杂系统的，比较适用的一种编程语言而已

完全无法替代java的，scala和java是相辅相成，荣辱与共的这么一种，共生关系

案例: 结合java IO流，做一个文件拷贝的案例

import java.io._

val fis = new FileInputStream(new File("C://Users//Administrator//Desktop//test.txt"))
val fos = new FileOutputStream(new File("C://Users//Administrator//Desktop//test3.txt"))

val buf = new Array[Byte](1024)
fis.read(buf)
fos.write(buf, 0, 1024)

fis.close()
fos.close()


val pw = new PrintWriter("C://Users//Administrator//Desktop//test4.txt")
pw.println("Hello World")
pw.close()


println("向文件中写数据：")
val writer = new PrintWriter(new File("test.txt")) //当前工程根目录下
for(i <- 1 to 100)
  writer.println(i)
  writer.close()
}

new FileWriter("/home/hadoop3/file/num1.txt",true)如果文件不存在，则会新建文件，true是在文件末尾追加写入，默认为false,从文件开头重新写，如果之前有内容，则会删除原有内容。

import java.io.FileWriter
println(Try{
  val out = new FileWriter("/home/hadoop3/file/num1.txt",true)
  for (i <- 0 to 15)
    out.write(i.toString)
  out.close()
})


def getSubdirIterator(dir: File): Iterator[File] = {
  val childDirs = dir.listFiles.filter(_.isDirectory)
  childDirs.toIterator ++ childDirs.toIterator.flatMap(getSubdirIterator _)
}

val iterator = getSubdirIterator(new File("C://Users//Administrator//Desktop"))

for(d <- iterator) println(d)

访问目录：

import java.nio.file._
val dirname = "/home/cay/scala-impatient/code"
val entries = Files.walk(Paths.get(dirname)) // or Files.list
try {
entries.forEach(p => println(p))
} finally {
entries.close()
}

如果要序列化，那么就必须让类，有一个@SerialVersionUID，定义一个版本号

要让类继承一个Serializable trait。

@SerialVersionUID(42L) class Person(val name: String) extends Serializable
val leo = new Person("leo")

import java.io._

val oos = new ObjectOutputStream(new FileOutputStream("C://Users//Administrator//Desktop//test.obj"))
oos.writeObject(leo)
oos.close()

val ois = new ObjectInputStream(new FileInputStream("C://Users//Administrator//Desktop//test.obj"))
val restoredLeo = ois.readObject().asInstanceOf[Person]
restoredLeo.name

五、控制台输入

print("控制台输入，请输入：")
val content = Console.readLine() //2.11.0按照下面的方法
println(content)
print("控制台输入，请再次输入：")
val content1  =  StdIn.readLine()
println(content1)

六、读取字符

val iter = source.buffered 

while(iter.hasNext){
  if(iter.next == '王'){
    println("wang")
  }else{
    println("-")
  }
}


import scala.io.Source
val source = Source.fromFile("myfile.txt", "UTF-8")
for (c <- source) 处理 c

//想查看某个字符但又不处理它的话，可以调用source对象的buffered方法
val source = Source.fromFile("myfile.txt", "UTF-8")
val iter = source.buffered
while (iter.hasNext){
    if(iter.head 是符合预期的)
        处理 iter.next
    else ...
}
source.close()

七、读取词法单元或数字

val iter 2= source.mkString.split("\\s+") 

val num = for(w <- iter2) yield w.toDouble 

for(i <- num) println(i)


val tokens = source.mkString.split("\\s+")

val numbers = for(w <- tokens) yield w.toDouble
//或者
val numbers = tokens.map(_.toDouble)

八、从URL或其它资源读取

val source1 = Source.fromURL("http://baidu.com")//URL读取
val source2 = Source.fromString("hello")//读取给定的字符串-多用于调试
import scala.io.StdIn
val ms=StdIn.readLine()

九、读取二进制文件

import java.io.{File, FileInputStream}
val file = new File(" ")
val in = new FileInputStream(file)
val bytes = new Array[Byte](file.length.toInt)
in.read(bytes)
in.close()

十、RandomAccessFile

该对象特点：

1，该对象只能操作文件，所以构造函数接收两种类型的参数。

a.字符串路径。

b.File对象。

2，该对象既可以对文件进行读取，也可以写入。

在进行对象实例化时，必须要指定的该对象的操作模式，r rw等。

注意；该对象在实例化时，如果要操作的文件不存在，会自动建立。

如果要操作的文件存在，则不会建立。

如果存在的文件有数据，那么在没有指定指针位置的情况下，写入数据，会将文件开头的数据覆盖。

import java.io.RandomAccessFile
val randomFile = new RandomAccessFile("/home/hadoop3/file/num.txt","rw")
val fileLength = randomFile.length; //得到文件长度

randomFile.seek(fileLength);//指针指向文件末尾
for(i<- 'a' to 'g')
randomFile.writeBytes(i.toString);//写入数据
randomFile.close();