Scala文件操作示例代码讲解

//1. 获取数据源文件对象.
val source:BufferedSource = Source.fromFile("数据源文件的路径","编码表")
//2. 以行为单位读取数据.
val lines:Iterator[String] = source.getLines()
//3. 将读取到的数据封装到列表中.
val list1:List[String] = lines.toList
//4. 千万别忘记关闭Source对象.
source.close()

import scala.io.Source
object ClassDemo01 {
	def main(args: Array[String]): Unit = {
		//1. 获取数据源对象.
		val source = Source.fromFile("./data/1.txt")
		//2.通过getLines()方法, 逐行获取文件中的数据.
		var lines: Iterator[String] = source.getLines()
		//3. 将获取到的每一条数据都封装到列表中.
		val list1 = lines.toList
		//4. 打印结果
		for(s <- list1) println(s)
		//5. 记得关闭source对象.
		source.close()
	}
}

import scala.io.Source
// 创建一个从文件中获取的Source对象
val source = Source.fromFile("demo.txt")
// 调用buffered方法，得到一个BufferedSource对象
val buffered = source.buffered

// 使用head方法查看下一个字符
println(buffered.head)
// 使用next方法消费下一个字符
println(buffered.next())
// 继续使用head方法查看下一个字符
println(buffered.head)
// 继续使用next方法消费下一个字符
println(buffered.next())

// 关闭Source对象source.close()

import scala.io.Source
// 创建一个从文件中获取的Source对象，并转换为一个BufferedSource对象
val buffered = Source.fromFile("demo.txt").buffered
// 循环判断是否有下一个元素
while (buffered.hasNext) {
  // 打印出当前元素，并消费掉
  print(buffered.next())
}
// 关闭Source对象
buffered.close()

//1. 获取数据源文件对象.
val source:BufferedSource = Source.fromFile("数据源文件的路径","编码表")
//2. 读取词法单元.
// \s表示空白字符(空格, \t, \r, \n等)
val arr:Array[String] = source.mkString.split("\\s+")
//3. 将字符串转成对应的整数
val num = strNumber.map(_.toInt)
//4. 千万别忘记关闭Source对象.
source.close()

import scala.io.Source
object ClassDemo03 {
	def main(args: Array[String]): Unit = {
	val source = Source.fromFile("./data/2.txt")
	// \s表示空白字符(空格, \t, \r, \n等)
	val strNumber = source.mkString.split("\\s+")
	//将字符串转成对应的整数
	val num = strNumber.map(_.toInt)
	for(a <- num) println(a + 1)
	}
}

//1. 获取数据源文件对象.
val source = Source.fromURL("https://www.csdn.net")
//2. 将数据封装到字符串中并打印.
println(source.mkString)

//1. 获取数据源文件对象.
val str = Source.fromString("CSDN")
println(str.getLines())

import scala.io.Source
object ClassDemo04 {
	def main(args: Array[String]): Unit = {
	val source = Source.fromURL("https://www.csdn.net")
	println(source.mkString)
	val str = Source.fromString("CSDN")
	println(str.getLines())
	}
}

object ClassDemo05 {
	def main(args: Array[String]): Unit = {
	val file = new File("./data/04.png")
	val fis = new FileInputStream(file)
	val bys = new Array[Byte](file.length().toInt)
	fis.read(bys)
	fis.close()
	println(bys.length)
	}
}

import java.io._
val pw = new PrintWriter(new File("hello.txt"))
pw.write("Hello, world")
pw.close()

val pw = new PrintWriter(new File("hello.txt"), "UTF-8")

import java.io._
val file = new File("test.txt")
val bw = new BufferedWriter(new FileWriter(file))
bw.write("We are learning Scala programming language")
bw.close()

val file = new File("test.txt")
val bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"))
bw.write("We are learning Scala programming language")
bw.close()

import java.io._
val file = new File("data.bin")
val fos = new FileOutputStream(file)
fos.write(42)
fos.close()

val pw = new FileOutputStream(new File("./data/3.txt"))
val pw = new FileOutputStream("./data/3.txt")

val pw = new PrintWriter(new File("./data/3.txt"))
val pw = new PrintWriter("./data/3.txt") // 错误

import org.apache.commons.io.FileUtils
FileUtils.writeStringToFile(new File("test.txt"), "Hello, world", "UTF-8")

import os._
os.write(os.pwd / "test.txt", "Hello, world")

// 定义一个case class Person
case class Person(var name: String, var age: Int)

// 创建Person样例类的对象p
val p = Person("张三", 23)
// 创建一个ObjectOutputStream对象，传入一个输出流作为参数
val oos = new ObjectOutputStream(new FileOutputStream("./data/4.txt"))
// 调用writeObject方法，将对象p写入到输出流中
oos.writeObject(p)
// 关闭输出流
oos.close()

// 创建一个ObjectInputStream对象，传入一个输入流作为参数
val ois = new ObjectInputStream(new FileInputStream("./data/4.txt"))
// 调用readObject方法，从输入流中读取对象，并转换为Person类型
var p: Person = ois.readObject().asInstanceOf[Person]
// 打印对象p
println(p)
// 关闭输入流
ois.close()

import java.io._
// 使用@SerialVersionUID注解指定版本号为100L
@SerialVersionUID(100L)
// 定义一个普通的类，并继承Serializable特质
class Person(var name: String, var age: Int) extends Serializable

val p = new Person("张三", 23)
val oos = new ObjectOutputStream(new FileOutputStream("./data/4.txt"))
oos.writeObject(p)
oos.close()
val ois = new ObjectInputStream(new FileInputStream("./data/4.txt"))
var p: Person = ois.readObject().asInstanceOf[Person]
println(p)

object ClassDemo08 {
	//1. 定义样例类Person, 属性: 姓名, 语文成绩, 数学成绩, 英语成绩, 且该类中有一个获取总成绩的方法.
	case class Student(name:String, chinese:Int, math:Int, english:Int) 	{
	def getSum() = chinese + math + english
	}
	def main(args: Array[String]): Unit = {
	//2. 获取数据源文件对象.
	val source = Source.fromFile("./data/student.txt")
	//3. 读取指定文件(./data/student.txt)中所有的数据, 并将其封装到List列表中.
	var studentList: Iterator[List[String]] = 	source.getLines().map(_.split(" ")).map(_.toList)
	//4. 定义可变的列表ListBuffer[Student], 用来记录所有学生的信息.
	val list = new ListBuffer[Student]()
	//5. 遍历第二步获取到的数据, 将其封装成Person类的对象后, 并添加到ListBuffer中.
	for(s <- studentList) {list += Student(s(0), s(1).toInt, s(2).toInt, s(3).toInt)}
	//6. 对第5步获取到的数据进行排序操作, 并将其转换成List列表.
	val sortList = list.sortBy(_.getSum()).reverse.toList
	//7. 按照指定格式, 通过BufferWriter将排序后的数据写入到目的地文件(./data/stu.txt)
	val bw = new BufferedWriter(new FileWriter("./data/stu.txt"))
	for(s <- sortList) bw.write(s"${s.name} ${s.chinese} ${s.math} 	${s.english}${s.getSum()}\r\n")
	//8. 关闭流对象
	bw.close()
	}
}