溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容介紹了“Scala文件操作方法有哪些”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！
在Scala語言的 Source單例對象 中, 提供了一些非常便捷的方法, 從而使開發者可以快速的從指定數據源(文本文件, URL地址等)中獲取數據, 在使用 Source單例對象 之前, 需要先導包, 即 import scala.io.Source.
我們可以以 行 為單位, 來讀取數據源中的數據, 返回值是一個 迭代器類型的對象 . 然后通過 toArray, toList 方法, 將這些數據放到數組或者列表中即可.
注意: Source類擴展自Iterator[Char]
格式
//1. 獲取數據源文件對象.
val source:BufferedSource = Source.fromFile("數據源文件的路徑","編碼表")
//2. 以行為單位讀取數據.
val lines:Iterator[String] = source.getLines()
//3. 將讀取到的數據封裝到列表中.
val list1:List[String] = lines.toList
//4. 千萬別忘記關閉Source對象.
source.close()需求
在當前項目下創建data文件夾, 并在其中創建1.txt文本文件, 文件內容如下:
好好學習, 天天向上!
Hadoop, Zookeeper, Flume, Spark
Flink, Sqoop, HBase
以行為單位讀取該文本文件中的數據, 并打印結果.
參考代碼
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()
}
}Scala還提供了 以字符為單位讀取數據 這種方式, 這種用法類似于迭代器, 讀取數據之后, 我們可以通過 hasNext(),next()方法 , 靈活的獲取數據.
什么是source.buffered方法
source.buffered方法是scala.io.Source類的一個成員方法，它可以將一個Source對象轉換為一個BufferedSource對象。BufferedSource對象是一個實現了BufferedIterator特質的對象，它可以提供一個緩沖區，用來存儲未被消費的元素。這樣可以提高讀取文件的效率，也可以方便地查看下一個元素而不消費它。
如何使用source.buffered方法
要使用source.buffered方法，首先需要導入scala.io.Source類，并創建一個Source對象，然后調用其buffered方法，得到一個BufferedSource對象。例如，以下代碼創建了一個從文件中獲取的Source對象，并轉換為一個BufferedSource對象：
import scala.io.Source
// 創建一個從文件中獲取的Source對象
val source = Source.fromFile("demo.txt")
// 調用buffered方法，得到一個BufferedSource對象
val buffered = source.buffered然后，可以使用BufferedSource對象的各種方法來按字符讀取文件。例如，以下代碼使用head方法來查看下一個字符，使用next方法來消費下一個字符，并打印出來：
// 使用head方法查看下一個字符 println(buffered.head) // 使用next方法消費下一個字符 println(buffered.next()) // 繼續使用head方法查看下一個字符 println(buffered.head) // 繼續使用next方法消費下一個字符 println(buffered.next())
最后，需要關閉Source對象，釋放資源：
// 關閉Source對象source.close()
下面給出一個完整的示例，演示如何使用source.buffered方法來按字符讀取文件，并打印出來。
首先，準備一個文本文件demo.txt，內容如下：
Hello, Scala!
你好，Scala！
然后，編寫以下代碼：
import scala.io.Source
// 創建一個從文件中獲取的Source對象，并轉換為一個BufferedSource對象
val buffered = Source.fromFile("demo.txt").buffered
// 循環判斷是否有下一個元素
while (buffered.hasNext) {
// 打印出當前元素，并消費掉
print(buffered.next())
}
// 關閉Source對象
buffered.close()最后，運行程序，可以看到輸出結果如下：
Hello, Scala!
你好，Scala！
所謂的詞法單元指的是 以特定符號間隔開的字符串 , 如果數據源文件中的數據都是 數字形式的字符串 , 我們可以很方便的從文件中直接獲取這些數據, 例如:
10 2 5
11 2
5 1 3 2
格式
//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()參考代碼
將上面的數字存入2.txt
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)
}
}Scala中提供了一種方式, 可以讓我們直接從指定的URL路徑, 或者其他源(例如: 特定的字符串)中直接讀取數據。
格式 從URL地址中讀取數據
//1. 獲取數據源文件對象.
val source = Source.fromURL("https://www.csdn.net")
//2. 將數據封裝到字符串中并打印.
println(source.mkString)從其他源讀取數據
//1. 獲取數據源文件對象.
val str = Source.fromString("CSDN")
println(str.getLines())需求
讀取https://www.csdn.net 頁面的數據, 并打印結果.
直接讀取字符串 CSDN, 并打印結果.
參考代碼
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())
}
}Scala沒有提供讀取二進制文件的方法, 我們需要通過Java類庫來實現.
需求 已知項目的data文件夾下有 05.png 這張圖片, 請讀取該圖片數據, 并將讀取到的字節數打印到控制臺上. 參考代碼
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)
}
}java.io.PrintWriter類是Java提供的一個用于寫入文本文件的類。它可以接受一個文件、一個輸出流或一個字符串作為參數，然后通過調用其write方法來向文件中寫入數據。例如，以下代碼可以向文件hello.txt中寫入一行文本：
import java.io._
val pw = new PrintWriter(new File("hello.txt"))
pw.write("Hello, world")
pw.close()使用PrintWriter類寫入文件時，有兩個需要注意的問題：
PrintWriter類不會拋出異常，而是設置一個布爾標志來表示是否發生了錯誤。可以通過調用其checkError方法來檢查是否有錯誤發生。
PrintWriter類默認使用平臺的字符編碼，這可能導致不同平臺之間的不一致。可以通過指定字符編碼來避免這個問題。例如，以下代碼使用了UTF-8編碼：
val pw = new PrintWriter(new File("hello.txt"), "UTF-8")java.io.FileWriter類是Java提供的另一個用于寫入文本文件的類。它是OutputStreamWriter的子類，可以接受一個文件或一個字符串作為參數，然后通過調用其write方法來向文件中寫入數據。例如，以下代碼可以向文件test.txt中寫入一行文本：
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()使用FileWriter類寫入文件時，有兩個需要注意的問題：
FileWriter類會拋出IOExceptions異常，所以需要使用try-catch-finally語句來處理異常和關閉文件。
FileWriter類默認使用平臺的字符編碼，這可能導致不同平臺之間的不一致。FileWriter類沒有提供指定字符編碼的構造器，所以如果需要指定字符編碼，可以使用OutputStreamWriter類代替。例如，以下代碼使用了UTF-8編碼：
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()FileOutputStream是Java提供的一個用于寫入二進制文件的類，它是OutputStream的子類，可以接受一個文件或一個字符串作為參數，然后通過調用其write方法來向文件中寫入字節數據。例如，以下代碼可以向文件data.bin中寫入一個整數：
import java.io._
val file = new File("data.bin")
val fos = new FileOutputStream(file)
fos.write(42)
fos.close()FileOutputStream類會拋出IOExceptions異常，所以需要使用try-catch-finally語句來處理異常和關閉文件。
已收到消息. FileOutputStream是Java提供的一個用于寫入二進制文件的類，它是OutputStream的子類，可以接受一個文件或一個字符串作為參數，然后通過調用其write方法來向文件中寫入字節數據。例如，以下代碼可以向文件data.bin中寫入一個整數： scala import java.io._ val file = new File("data.bin") val fos = new FileOutputStream(file) fos.write(42) fos.close() FileOutputStream類會拋出IOExceptions異常，所以需要使用try-catch-finally語句來處理異常和關閉文件。
因為FileOutputStream類有兩種構造器，一種接受一個文件對象作為參數，一種接受一個字符串作為參數。如果接受一個字符串作為參數，那么它會自動創建一個文件對象。所以，以下兩種寫法是等價的：
val pw = new FileOutputStream(new File("./data/3.txt"))
val pw = new FileOutputStream("./data/3.txt")但是，如果使用PrintWriter類或FileWriter類，那么就必須使用一個文件對象作為參數，不能使用一個字符串。所以，以下兩種寫法是不等價的：
val pw = new PrintWriter(new File("./data/3.txt"))
val pw = new PrintWriter("./data/3.txt") // 錯誤除了Java提供的類之外，還有一些第三方庫可以用來寫入文件，例如Apache Commons IO1和os-lib2等。這些庫通常提供了更簡潔和高效的API，也支持更多的功能和格式。例如，以下代碼使用了Apache Commons IO庫的FileUtils類來寫入文件，并指定了字符編碼：
import org.apache.commons.io.FileUtils
FileUtils.writeStringToFile(new File("test.txt"), "Hello, world", "UTF-8")以下代碼使用了os-lib庫的os.File對象來寫入文件，并返回一個字節長度：
import os._ os.write(os.pwd / "test.txt", "Hello, world")
在Scala中，如果想將對象傳輸到其他虛擬機，或者臨時存儲，就可以通過序列化和反序列化來實現了。
序列化：把對象寫到文件中的過程。
反序列化：從文件中加載對象的過程。
一個類的對象要想實現序列化和反序列化操作，則該類必須繼承Serializable特質。Serializable特質是一個空特質，它沒有任何方法和字段，只是用來標記一個類是否可以被序列化和反序列化。
要實現序列化操作，可以使用java.io.ObjectOutputStream類，它是一個用于寫入對象的輸出流。它可以接受一個輸出流作為參數，然后通過調用其writeObject方法來寫入對象。
要實現反序列化操作，可以使用java.io.ObjectInputStream類，它是一個用于讀取對象的輸入流。它可以接受一個輸入流作為參數，然后通過調用其readObject方法來讀取對象。
下面給出一個簡單的示例，演示如何使用case class和object來實現序列化和反序列化操作。
首先，定義一個case class Person，屬性為姓名和年齡。注意，case class會自動繼承Serializable特質，所以不需要顯式地寫出來。
// 定義一個case class Person case class Person(var name: String, var age: Int)
然后，創建Person樣例類的對象p，并通過序列化操作將對象p寫入到項目下的data文件夾下的4.txt文本文件中。
// 創建Person樣例類的對象p
val p = Person("張三", 23)
// 創建一個ObjectOutputStream對象，傳入一個輸出流作為參數
val oos = new ObjectOutputStream(new FileOutputStream("./data/4.txt"))
// 調用writeObject方法，將對象p寫入到輸出流中
oos.writeObject(p)
// 關閉輸出流
oos.close()最后，通過反序列化操作從項目下的data文件夾下的4.txt文件中，讀取對象p，并打印出來。
// 創建一個ObjectInputStream對象，傳入一個輸入流作為參數
val ois = new ObjectInputStream(new FileInputStream("./data/4.txt"))
// 調用readObject方法，從輸入流中讀取對象，并轉換為Person類型
var p: Person = ois.readObject().asInstanceOf[Person]
// 打印對象p
println(p)
// 關閉輸入流
ois.close()除了使用Serializable特質之外，還可以使用@SerialVersionUID注解來指定一個版本號。這樣可以避免不同版本的類之間的兼容性問題。例如，以下代碼定義了一個普通的類，并添加了注解：
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)概述
已知項目下的data文件夾的student.txt文本文件中, 記錄了一些學員的成績, 如下: 格式為: 姓名 語文成績 數學成績 英語成績
張三 37 90 100
李四 90 73 81
王五 60 90 76
趙六 89 21 72
田七 100 100 100
按照學員的總成績降序排列后, 按照 姓名 語文成績 數學成績 英語成績 總成績 的格式, 將數據寫到項目下的data文件夾的stu.txt文件中.
** 步驟**
定義樣例類Person, 屬性為: 姓名, 語文成績, 數學成績, 英語成績, 且該類中有一個獲取總成績的方法.
讀取指定文件(./data/student.txt)中所有的數據, 并將其封裝到List列表中.
定義可變的列表ListBuffer[Student], 用來記錄所有學生的信息.
遍歷第二步獲取到的數據, 將其封裝成Person類的對象后, 并添加到ListBuffer中.
對第4步獲取到的數據進行排序操作, 并將其轉換成List列表.
按照指定格式, 通過BufferWriter將排序后的數據寫入到目的地文件中(./data/stu.txt)
關閉流對象.
參考代碼
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()
}
}“Scala文件操作方法有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
