Kotlin文件与IO操作指南

Kotlin 文件系统基础

在 Kotlin 中进行文件与 IO 操作，首先要对文件系统的基本概念和操作有清晰的理解。Kotlin 提供了丰富的类和函数来处理文件，这些功能使得文件的创建、读取、写入和删除等操作变得相对简单。

文件路径

在 Kotlin 中，文件路径是定位文件的关键。路径可以是相对路径或绝对路径。相对路径是相对于当前工作目录的路径，而绝对路径是从文件系统根目录开始的完整路径。例如，在 Unix - 类系统中，绝对路径可能是 /home/user/file.txt，而相对路径可能是 subdirectory/file.txt，这里假设当前工作目录包含 subdirectory 目录。

在 Windows 系统中，绝对路径可能类似于 C:\Users\user\file.txt，相对路径的格式与 Unix - 类系统类似，但路径分隔符使用反斜杠（\），不过在 Kotlin 字符串中，由于反斜杠是转义字符，所以需要写成 \\ 或者使用原始字符串（"""）。例如：

// 使用转义字符
val windowsPath1 = "C:\\Users\\user\\file.txt"
// 使用原始字符串
val windowsPath2 = """C:\Users\user\file.txt"""

文件对象

Kotlin 中，java.io.File 类用于表示文件和目录。虽然 Kotlin 没有专门为文件操作引入全新的类，但通过对 Java 的 File 类进行扩展，提供了更简洁和 Kotlin 风格的操作方式。

创建一个 File 对象很简单，只需要传入文件路径即可：

import java.io.File

// 创建一个表示文件的 File 对象
val file = File("example.txt")
// 创建一个表示目录的 File 对象
val directory = File("myDirectory")

文件的创建与删除

掌握文件的创建和删除操作是文件管理的基础。Kotlin 提供了便捷的方法来完成这些任务。

创建文件

要在 Kotlin 中创建一个新文件，可以使用 File 类的 createNewFile() 方法。这个方法会尝试在指定路径创建一个新的空文件，如果文件已经存在，则返回 false，否则返回 true。

import java.io.File
import java.io.IOException

fun createFile() {
    val file = File("newFile.txt")
    try {
        val created = file.createNewFile()
        if (created) {
            println("文件创建成功")
        } else {
            println("文件已存在")
        }
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

另外，如果需要创建多级目录结构，可以使用 mkdirs() 方法。例如，要创建一个路径为 parent/child/subchild 的目录结构：

import java.io.File

fun createDirectories() {
    val dir = File("parent/child/subchild")
    val created = dir.mkdirs()
    if (created) {
        println("目录创建成功")
    } else {
        println("目录创建失败或已存在")
    }
}

删除文件和目录

删除文件或目录同样简单。对于文件，可以使用 delete() 方法直接删除。如果删除成功，该方法返回 true，否则返回 false。例如：

import java.io.File

fun deleteFile() {
    val file = File("newFile.txt")
    val deleted = file.delete()
    if (deleted) {
        println("文件删除成功")
    } else {
        println("文件删除失败")
    }
}

对于目录，delete() 方法只能删除空目录。如果要删除非空目录及其所有内容，需要递归地删除目录中的所有文件和子目录。以下是一个递归删除目录的示例：

import java.io.File

fun deleteDirectory(dir: File) {
    if (dir.isDirectory) {
        dir.listFiles()?.forEach {
            if (it.isDirectory) {
                deleteDirectory(it)
            } else {
                it.delete()
            }
        }
    }
    dir.delete()
}

fun main() {
    val directory = File("parent")
    deleteDirectory(directory)
}

文件的读取操作

文件读取是文件 IO 操作中最常见的任务之一。Kotlin 提供了多种方式来读取文件内容，从简单的按行读取到更复杂的二进制数据读取。

按行读取文本文件

按行读取文本文件是一种常见的操作。Kotlin 可以使用 BufferedReader 来高效地完成这个任务。通过 FileReader 来创建 BufferedReader 对象，然后使用 readLine() 方法逐行读取文件内容。

import java.io.BufferedReader
import java.io.FileReader
import java.io.IOException

fun readFileLineByLine() {
    try {
        val reader = BufferedReader(FileReader("example.txt"))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

上述代码中，BufferedReader 的 readLine() 方法每次读取文件的一行内容，当读取到文件末尾时，返回 null。also 函数用于在读取一行后将其赋值给 line 变量，并返回该行内容，这样可以在 while 循环条件中判断是否到达文件末尾。

另外，Kotlin 还提供了更简洁的方式来按行读取文件。可以使用 File 类的扩展函数 bufferedReader()，然后直接对其使用 forEachLine 方法：

import java.io.File

fun readFileLineByLineSimplified() {
    File("example.txt").bufferedReader().forEachLine { line ->
        println(line)
    }
}

读取整个文本文件内容

如果需要一次性读取整个文本文件的内容，可以使用 readText() 方法。这个方法会将文件内容读取为一个字符串。

import java.io.File
import java.io.IOException

fun readEntireFile() {
    try {
        val content = File("example.txt").readText()
        println(content)
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

读取二进制文件

对于二进制文件，如图片、音频或视频文件，需要使用 InputStream 来读取。Kotlin 可以通过 FileInputStream 来创建 InputStream 对象。以下是一个简单的示例，将二进制文件的内容读取到一个字节数组中：

import java.io.FileInputStream
import java.io.IOException

fun readBinaryFile() {
    try {
        val inputStream = FileInputStream("image.jpg")
        val buffer = ByteArray(inputStream.available())
        inputStream.read(buffer)
        inputStream.close()
        // 这里可以对字节数组 buffer 进行处理
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

在上述代码中，available() 方法返回输入流中可以读取的字节数，read(buffer) 方法将输入流中的数据读取到字节数组 buffer 中。

文件的写入操作

与文件读取类似，Kotlin 也提供了多种方式来写入文件内容，包括文本写入和二进制写入。

写入文本到文件

要将文本写入文件，可以使用 FileWriter 和 BufferedWriter。FileWriter 用于将字符写入文件，BufferedWriter 则提供了缓冲功能，提高写入效率。

import java.io.BufferedWriter
import java.io.FileWriter
import java.io.IOException

fun writeTextToFile() {
    try {
        val writer = BufferedWriter(FileWriter("output.txt"))
        writer.write("这是要写入文件的第一行文本\n")
        writer.write("这是第二行文本\n")
        writer.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

在上述代码中，write() 方法用于将文本写入文件，\n 用于表示换行符。注意，在写入完成后，需要调用 close() 方法关闭 BufferedWriter，以确保所有数据都被写入文件。

Kotlin 还提供了更简洁的方式来写入文本文件。可以使用 File 类的扩展函数 bufferedWriter()，然后直接使用 use 函数来简化资源管理：

import java.io.File

fun writeTextToFileSimplified() {
    File("output.txt").bufferedWriter().use { writer ->
        writer.write("这是简化方式写入的第一行文本\n")
        writer.write("这是第二行文本\n")
    }
}

use 函数会在代码块执行完毕后自动关闭 BufferedWriter，无需手动调用 close() 方法。

追加文本到文件

如果要在文件末尾追加文本，可以在创建 FileWriter 时传入 true 作为第二个参数，表示追加模式。

import java.io.BufferedWriter
import java.io.FileWriter
import java.io.IOException

fun appendTextToFile() {
    try {
        val writer = BufferedWriter(FileWriter("output.txt", true))
        writer.write("这是追加到文件的文本\n")
        writer.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

写入二进制数据到文件

写入二进制数据到文件需要使用 OutputStream。可以通过 FileOutputStream 来创建 OutputStream 对象。以下是一个将字节数组写入二进制文件的示例：

import java.io.FileOutputStream
import java.io.IOException

fun writeBinaryDataToFile() {
    val data = byteArrayOf(0x48, 0x65, 0x6C, 0x6C, 0x6F) // 对应 "Hello" 的字节数组
    try {
        val outputStream = FileOutputStream("binaryFile.bin")
        outputStream.write(data)
        outputStream.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

在上述代码中，write(data) 方法将字节数组 data 写入到文件 binaryFile.bin 中。同样，在写入完成后，需要关闭 OutputStream。

文件属性操作

除了基本的文件创建、读取、写入和删除操作外，Kotlin 还提供了获取和修改文件属性的功能。

获取文件属性

可以使用 File 类的方法来获取文件的各种属性，如文件大小、修改时间、是否为目录等。

import java.io.File
import java.text.SimpleDateFormat
import java.util.Date

fun getFileAttributes() {
    val file = File("example.txt")
    if (file.exists()) {
        println("文件路径: ${file.path}")
        println("文件大小: ${file.length()} 字节")
        val lastModified = Date(file.lastModified())
        val dateFormat = SimpleDateFormat("yyyy - MM - dd HH:mm:ss")
        println("最后修改时间: ${dateFormat.format(lastModified)}")
        println("是否为目录: ${file.isDirectory}")
    } else {
        println("文件不存在")
    }
}

在上述代码中，length() 方法返回文件的大小（以字节为单位），lastModified() 方法返回文件最后修改的时间戳，通过 Date 类和 SimpleDateFormat 可以将时间戳格式化为人类可读的日期和时间。isDirectory 属性用于判断文件是否为目录。

修改文件属性

修改文件属性相对较为复杂，不同操作系统对文件属性的支持和修改方式有所不同。在 Kotlin 中，可以使用 java.nio.file.attribute.FileAttribute 相关的类来进行一些基本的属性修改，例如修改文件的访问权限。

以下是一个在 Unix - 类系统中修改文件权限的示例：

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.attribute.PosixFilePermission
import java.nio.file.attribute.PosixFilePermissions

fun setFilePermissions() {
    val path = Paths.get("example.txt")
    val perms = PosixFilePermissions.fromString("rw - r - - r - -")
    try {
        Files.setPosixFilePermissions(path, perms)
        println("文件权限已修改")
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

在上述代码中，PosixFilePermissions.fromString() 方法根据字符串表示创建文件权限对象，Files.setPosixFilePermissions() 方法用于设置文件的权限。注意，这种方法仅适用于支持 POSIX 文件权限的系统，如 Unix 和 Linux。在 Windows 系统中，文件权限的管理方式有所不同，需要使用不同的 API 来进行操作。

高级文件与 IO 操作

在实际应用中，有时需要更高级的文件和 IO 操作，例如处理大文件、流的转换和管道操作等。

处理大文件

处理大文件时，一次性读取整个文件内容可能会导致内存溢出。因此，需要采用逐块读取和处理的方式。以下是一个示例，将大文件按块读取并进行简单的处理（例如计算文件中特定字符的出现次数）：

import java.io.BufferedInputStream
import java.io.FileInputStream
import java.io.IOException

fun processLargeFile() {
    val bufferSize = 1024 * 1024 // 1MB 的缓冲区大小
    val buffer = ByteArray(bufferSize)
    var charCount = 0
    try {
        val inputStream = BufferedInputStream(FileInputStream("largeFile.txt"))
        var bytesRead: Int
        while (inputStream.read(buffer).also { bytesRead = it } != -1) {
            for (i in 0 until bytesRead) {
                if (buffer[i].toChar() == 'a') {
                    charCount++
                }
            }
        }
        inputStream.close()
        println("字符 'a' 的出现次数: $charCount")
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

在上述代码中，使用 BufferedInputStream 以 1MB 的缓冲区大小逐块读取文件内容。每次读取后，在缓冲区中查找特定字符（这里是 'a'）并统计其出现次数。

流的转换和管道操作

流的转换和管道操作在处理复杂的 IO 任务时非常有用。例如，将一个字符流转换为字节流，或者将多个流连接起来形成一个处理管道。

以下是一个将 FileReader 转换为 InputStreamReader，然后将其内容写入到 FileWriter 的示例：

import java.io.FileReader
import java.io.FileWriter
import java.io.IOException
import java.io.InputStreamReader
import java.net.URL

fun streamTransformationAndPiping() {
    try {
        val url = URL("http://example.com")
        val inputStream = url.openStream()
        val reader = InputStreamReader(inputStream)
        val fileWriter = FileWriter("output.txt")
        reader.forEachLine { line ->
            fileWriter.write(line)
            fileWriter.write("\n")
        }
        reader.close()
        fileWriter.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

在上述代码中，首先通过 URL 打开一个网络流，然后使用 InputStreamReader 将字节流转换为字符流，接着将字符流的内容逐行写入到 FileWriter 中，实现了从网络流到文件的内容传输。

异常处理

在进行文件和 IO 操作时，不可避免地会遇到各种异常情况，如文件不存在、权限不足、磁盘空间不足等。正确处理这些异常对于程序的健壮性至关重要。

在前面的示例中，我们已经看到了一些简单的异常处理方式，通常是捕获 IOException 并打印堆栈跟踪信息。然而，在实际应用中，可能需要更精细的异常处理策略。

区分不同类型的异常

IOException 是文件和 IO 操作中常见的异常基类，但它包含了多种具体的异常类型，如 FileNotFoundException、SecurityException、OutOfMemoryError 等。可以根据不同的异常类型采取不同的处理措施。

import java.io.File
import java.io.FileNotFoundException
import java.io.IOException
import java.io.RandomAccessFile

fun handleExceptions() {
    val file = File("nonexistentFile.txt")
    try {
        val randomAccessFile = RandomAccessFile(file, "r")
        // 这里进行文件读取操作
        randomAccessFile.close()
    } catch (e: FileNotFoundException) {
        println("文件未找到: ${e.message}")
        // 可以在这里尝试创建文件或提示用户
    } catch (e: SecurityException) {
        println("权限不足: ${e.message}")
        // 可以提示用户检查权限
    } catch (e: IOException) {
        println("其他 IO 异常: ${e.message}")
        e.printStackTrace()
    }
}

在上述代码中，通过分别捕获不同类型的异常，能够针对不同的异常情况给出更有针对性的提示或处理。

使用 try - with - resources

在处理文件和流时，确保资源（如文件句柄、流对象）正确关闭非常重要，否则可能会导致资源泄漏。try - with - resources 语句（在 Kotlin 中通过 use 函数实现）可以自动关闭资源，无论代码块中是否发生异常。

import java.io.File
import java.io.FileReader
import java.io.IOException

fun useTryWithResources() {
    File("example.txt").bufferedReader().use { reader ->
        try {
            reader.forEachLine { line ->
                println(line)
            }
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}

在上述代码中，use 函数会在代码块执行完毕后（无论是正常结束还是抛出异常）自动关闭 BufferedReader，无需手动调用 close() 方法，有效避免了资源泄漏问题。

通过以上对 Kotlin 文件与 IO 操作的详细介绍，包括文件系统基础、文件的创建与删除、读取和写入操作、文件属性操作、高级操作以及异常处理等方面，相信读者能够全面掌握 Kotlin 在文件和 IO 领域的应用，开发出高效、健壮的文件处理程序。在实际应用中，应根据具体需求选择合适的操作方式，并注重异常处理和资源管理，以确保程序的稳定性和可靠性。